Privacidad de Datos y Cumplimiento GDPR

Visión General

El Reglamento General de Protección de Datos (GDPR) establece reglas estrictas para el manejo de datos personales de ciudadanos de la UE. Más allá del cumplimiento legal, el privacy-by-design construye confianza del usuario y reduce el impacto de brechas. Este recurso cubre controles técnicos prácticos: gestión de consentimientos, minimización de datos, anonimización, derecho al olvido y portabilidad de datos.

Cuándo Usar

Usa este recurso cuando:

• Procesas datos personales de residentes de la UE (clientes, empleados, leads)
• Construyes flujos de consentimiento para marketing, analytics o sharing con terceros
• Implementas políticas de retención de datos y eliminación automática
• Te preparas para data subject access requests (DSARs)

Solución

Esquema de Gestión de Consentimientos (PostgreSQL)

CREATE TABLE user_consents (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    purpose VARCHAR(50) NOT NULL,  -- 'marketing', 'analytics', 'third_party'
    granted BOOLEAN NOT NULL DEFAULT false,
    granted_at TIMESTAMPTZ,
    withdrawn_at TIMESTAMPTZ,
    ip_address INET,
    user_agent TEXT
);

-- Índice para búsquedas DSAR rápidas
CREATE INDEX idx_consents_user ON user_consents(user_id);

Pipeline de Anonimización (Python)

import hashlib
import hmac
from datetime import datetime

SECRET_KEY = b"rotation-secret-2024"

def pseudonymize(user_id: str) -> str:
    """Reemplaza PII con hash irreversible para analytics."""
    return hmac.new(SECRET_KEY, user_id.encode(), hashlib.sha256).hexdigest()[:16]

def anonymize_age(birth_date: datetime) -> str:
    """Agrupa edad en rangos para uso estadístico."""
    age = (datetime.now() - birth_date).days // 365
    if age < 18: return "<18"
    if age < 25: return "18-24"
    if age < 35: return "25-34"
    return "35+"

Derecho al Olvido (Node.js)

async function eraseUserData(userId) {
  // 1. Eliminar o anonimizar registro de usuario
  await db.users.update(userId, {
    email: null,
    name: 'Usuario Eliminado',
    deleted_at: new Date()
  });
  
  // 2. Eliminar datos relacionados en cascada
  await db.orders.anonymize({ user_id: userId });
  await db.sessions.delete({ user_id: userId });
  await db.activity_logs.delete({ user_id: userId });
  
  // 3. Notificar a terceros
  await webhookService.notify('user.deleted', { userId });
  
  // 4. Loggear la eliminación para auditoría
  await auditLog.create({ action: 'erasure', user_id: userId, timestamp: new Date() });
}

Explicación

Seis principios del GDPR con implementación técnica:

1. Legalidad: Almacena registros de consentimiento con timestamp, IP y propósito
2. Limitación de propósito: Etiqueta datos con propósitos permitidos; rechaza uso no autorizado
3. Minimización de datos: Recolecta solo lo necesario; usa validación de formularios
4. Exactitud: Permite a usuarios actualizar perfiles; valida inputs
5. Limitación de almacenamiento: TTL en datos personales; auto-eliminación después del período de retención
6. Integridad/confidencialidad: Encripta en reposo; hashea para analytics; controles de acceso

Derechos del Sujeto de Datos (DSRs):

• Acceso: Exportar todos los datos personales en formato legible por máquina (JSON)
• Rectificación: Actualizar datos incorrectos vía portal self-service
• Olvido: Eliminar o anonimizar dentro de 30 días (con audit trail)
• Portabilidad: Exportar datos en formato estándar (JSON, CSV)
• Objeción: Detener procesamiento para marketing o profiling

Variantes

Control	Implementación	Esfuerzo
Banners de consentimiento	Cookie consent SDK	Bajo
Data mapping	Auditoría manual + tags de schema	Medio
Auto-eliminación	Cron jobs con reglas de retención	Medio
Pseudonimización	Hashing + rotación de claves	Medio
Dashboard DPO	Herramienta admin custom	Alto

Lo que funciona

• Privacy by default: Nuevas capacidades opt-out por defecto; requiere opt-in explícito
• Encripta PII en reposo: Usa AES-256 para bases de datos, S3 y backups
• Loguea acceso a datos personales: Audita quién accedió qué y cuándo
• Separa datos de analytics: Pseudonimiza antes de enviar a herramientas BI
• Documenta tu base legal: Contrato, consentimiento o interés legítimo por tipo de dato

Errores Comunes

1. Consentimiento implícito: Checkboxes pre-marcadas o términos escondidos no cuentan bajo GDPR
2. Sin límites de retención: Mantener datos de usuario para siempre viola limitación de almacenamiento
3. Filtración a terceros: Analytics, ads y CDNs reciben PII sin conocimiento del usuario. Ejecuta auditorías de dependencias regularmente.
4. Ignorar eliminación de backups: Los datos de usuario borrados persisten en snapshots antiguos de base de datos
5. Consentimiento único para todo: Las cookies de marketing y funcionales necesitan consentimiento separado

Soluciones Avanzadas

Exportación de portabilidad de datos (Python)

El Artículo 20 del GDPR requiere exportar datos de usuario en formato legible por máquina:

import json
from datetime import datetime
from io import BytesIO
from zipfile import ZipFile

def export_user_data(user_id: str, db) -> bytes:
    """Exportar todos los datos personales de un usuario como ZIP con archivos JSON."""
    data = {
        'profile': db.get_user_profile(user_id),
        'orders': db.get_user_orders(user_id),
        'consents': db.get_user_consents(user_id),
        'activity_logs': db.get_user_activity(user_id),
    }

    # Remover campos internos y mantener solo datos personales
    for section in data.values():
        if isinstance(section, list):
            for item in section:
                item.pop('id', None)
                item.pop('internal_status', None)
        elif isinstance(section, dict):
            section.pop('id', None)

    export = {
        'user_id': user_id,
        'exported_at': datetime.utcnow().isoformat() + 'Z',
        'format': 'GDPR Article 20 Data Portability',
        'data': data,
    }

    json_bytes = json.dumps(export, indent=2, default=str).encode('utf-8')

    # Empaquetar como ZIP para descarga
    buffer = BytesIO()
    with ZipFile(buffer, 'w') as zf:
        zf.writestr('user_data.json', json_bytes)

    return buffer.getvalue()

# Uso en Flask
@app.route('/api/gdpr/export', methods=['POST'])
@require_auth
def request_export():
    user_id = request.user.id
    data = export_user_data(user_id, db)
    return send_file(
        BytesIO(data),
        mimetype='application/zip',
        as_attachment=True,
        download_name=f'gdpr_export_{user_id}.zip'
    )

API de gestión de consentimientos (Node.js)

const express = require('express');
const router = express.Router();

// Otorgar consentimiento para un propósito específico
router.post('/consent/:purpose', async (req, res) => {
  const { purpose } = req.params;
  const userId = req.user.id;
  const allowedPurposes = ['marketing', 'analytics', 'third_party', 'cookies_functional'];

  if (!allowedPurposes.includes(purpose)) {
    return res.status(400).json({ error: 'Propósito de consentimiento inválido' });
  }

  const consent = await db.consents.upsert({
    user_id: userId,
    purpose,
    granted: true,
    granted_at: new Date(),
    withdrawn_at: null,
    ip_address: req.ip,
    user_agent: req.headers['user-agent'],
  });

  res.json({ purpose, granted: true, granted_at: consent.granted_at });
});

// Retirar consentimiento
router.delete('/consent/:purpose', async (req, res) => {
  const { purpose } = req.params;
  const userId = req.user.id;

  await db.consents.update(
    { user_id: userId, purpose, granted: true },
    { granted: false, withdrawn_at: new Date() }
  );

  // Trigger downstream: detener emails de marketing, deshabilitar tracking
  await eventBus.emit('consent.withdrawn', { userId, purpose });

  res.json({ purpose, granted: false, withdrawn_at: new Date().toISOString() });
});

// Obtener todos los consentimientos del usuario actual
router.get('/consents', async (req, res) => {
  const userId = req.user.id;
  const consents = await db.consents.findActive({ user_id: userId });
  res.json(consents);
});

Auto-eliminación por retención de datos (Python cron)

import logging
from datetime import datetime, timedelta

logger = logging.getLogger(__name__)

RETENTION_POLICIES = {
    'inactive_users': timedelta(days=730),    # 2 años
    'activity_logs': timedelta(days=365),     # 1 año
    'session_data': timedelta(days=30),       # 30 días
    'marketing_data': timedelta(days=540),    # 18 meses
}

def run_retention_cleanup(db):
    """Eliminar o anonimizar datos pasados el período de retención."""
    now = datetime.utcnow()

    for data_type, retention in RETENTION_POLICIES.items():
        cutoff = now - retention
        deleted_count = 0

        if data_type == 'inactive_users':
            # Anonimizar en lugar de eliminar para preservar historial de órdenes
            deleted_count = db.execute("""
                UPDATE users
                SET email = NULL, name = 'Anonymized User',
                    phone = NULL, deleted_at = NOW()
                WHERE last_login < %s AND deleted_at IS NULL
            """, (cutoff,)).rowcount

        elif data_type == 'activity_logs':
            deleted_count = db.execute("""
                DELETE FROM activity_logs
                WHERE created_at < %s
            """, (cutoff,)).rowcount

        elif data_type == 'session_data':
            deleted_count = db.execute("""
                DELETE FROM sessions
                WHERE expires_at < %s
            """, (cutoff,)).rowcount

        logger.info(f'Limpieza de retención: {data_type} - {deleted_count} registros procesados')

    # Loggear entrada de auditoría
    db.execute("""
        INSERT INTO audit_log (action, details, created_at)
        VALUES ('retention_cleanup', %s, NOW())
    """, (f'Completado en {now.isoformat()}',))

Banner de consentimiento de cookies (JavaScript)

const CONSENT_KEY = 'cookie_consent_v1';

function loadConsentBanner() {
  const existing = localStorage.getItem(CONSENT_KEY);
  if (existing) {
    applyConsent(JSON.parse(existing));
    return;
  }

  const banner = document.createElement('div');
  banner.id = 'consent-banner';
  banner.innerHTML = `
    <div class="rg">
      <p>Usamos cookies para analytics y marketing. Puedes elegir cuáles habilitar.</p>
      <div class="ri">
        <label><input type="checkbox" id="consent-functional" checked disabled> Funcionales (requeridas)</label>
        <label><input type="checkbox" id="consent-analytics"> Analytics</label>
        <label><input type="checkbox" id="consent-marketing"> Marketing</label>
      </div>
      <div class="rj">
        <button id="consent-reject">Rechazar Todas</button>
        <button id="consent-accept">Aceptar Seleccionadas</button>
      </div>
    </div>
  `;
  document.body.appendChild(banner);

  document.getElementById('consent-accept').onclick = () => {
    const consent = {
      functional: true,
      analytics: document.getElementById('consent-analytics').checked,
      marketing: document.getElementById('consent-marketing').checked,
      timestamp: new Date().toISOString(),
    };
    localStorage.setItem(CONSENT_KEY, JSON.stringify(consent));
    applyConsent(consent);
    banner.remove();
  };

  document.getElementById('consent-reject').onclick = () => {
    const consent = {
      functional: true,
      analytics: false,
      marketing: false,
      timestamp: new Date().toISOString(),
    };
    localStorage.setItem(CONSENT_KEY, JSON.stringify(consent));
    applyConsent(consent);
    banner.remove();
  };
}

function applyConsent(consent) {
  if (consent.analytics) {
    loadAnalytics();
  }
  if (consent.marketing) {
    loadMarketingPixels();
  }
}