Curso de SELinux

Entender SELinux como implementación de control de acceso obligatorio integrada en el kernel Linux.

Revisar el papel de Linux Security Modules dentro de la arquitectura de seguridad.

Diferenciar policy, labels, security context, domains, types, roles, users, levels y decisiones de acceso.

Analizar cómo el kernel consulta la política antes de permitir una operación.

Entender el concepto de type enforcement como base del control de acceso en SELinux.

Relacionar procesos con dominios y objetos con tipos.

Revisar cómo SELinux complementa, pero no sustituye, los permisos tradicionales del sistema.

Evitar confundir usuario Linux con usuario SELinux.

Identificar componentes de userspace: libselinux, policycoreutils, setroubleshoot, audit y semanage.

Taller: mapear una operación de acceso desde proceso hasta decisión SELinux.

Diferenciar modos enforcing, permissive y disabled.

Cambiar temporalmente entre enforcing y permissive con criterio de diagnóstico.

Configurar modo persistente en archivos de configuración del sistema.

Evitar pasar a disabled sin plan, causa documentada y aprobación.

Revisar consecuencias de arrancar sin SELinux y volver a activarlo.

Validar estado con `getenforce`, `sestatus` y comandos equivalentes.

Configurar políticas targeted, MLS o variantes disponibles según distribución.

Interpretar errores de arranque relacionados con etiquetas incorrectas.

Crear procedimiento de cambio seguro de modo.

Taller: alternar modos en laboratorio, generar denegaciones y analizar diferencias.

Interpretar contexto SELinux completo: usuario, rol, tipo y nivel.

Usar `ls -Z`, `ps -Z`, `id -Z` y herramientas similares para ver contextos.

Diferenciar contexto de fichero, proceso, puerto, usuario, socket y recurso.

Entender por qué el tipo suele ser la parte más relevante en administración diaria.

Evitar corregir permisos Unix cuando el problema real es el contexto SELinux.

Detectar etiquetas rotas tras copiar, mover, restaurar o desplegar ficheros.

Comparar contextos esperados y contextos reales.

Documentar patrones de labels por servicio.

Crear checklist de revisión de contextos.

Taller: diagnosticar acceso denegado causado por etiqueta incorrecta.

Entender Type Enforcement como mecanismo central de aislamiento entre dominios y tipos.

Diferenciar dominio de proceso y tipo de objeto.

Analizar cómo un servicio confinado solo puede acceder a recursos autorizados por política.

Revisar ejemplos con `httpd_t`, `sshd_t`, `mysqld_t`, `named_t` u otros dominios habituales.

Evitar ejecutar servicios en dominios no esperados o unconfined sin justificación.

Analizar transiciones de dominio al arrancar servicios.

Diagnosticar procesos que no cambian al dominio correcto por ejecución manual o ruta incorrecta.

Revisar impacto de scripts personalizados sobre transiciones SELinux.

Documentar dominios esperados por servicio.

Taller: provocar y corregir un servicio ejecutado en dominio incorrecto.

Diferenciar usuarios Linux y usuarios SELinux.

Entender roles SELinux y su relación con políticas RBAC.

Revisar usuarios comunes como `unconfined_u`, `staff_u`, `user_u`, `sysadm_u` u otros según distribución.

Mapear usuarios Linux a usuarios SELinux con `semanage login`.

Evitar que todos los usuarios administrativos operen siempre como unconfined.

Definir perfiles para usuarios de administración, operadores y usuarios estándar.

Revisar restricciones para shells, sudo, acceso remoto y ejecución de comandos.

Documentar excepciones y cuentas privilegiadas.

Auditar mapeos de usuarios y roles.

Taller: crear usuario confinado y validar qué acciones puede y no puede realizar.

Entender niveles de sensibilidad y categorías en SELinux.

Diferenciar MCS y MLS y cuándo se usan en entornos reales.

Revisar sintaxis de niveles como `s0`, categorías y rangos.

Analizar uso de MCS en aislamiento de contenedores.

Evitar activar modelos complejos sin necesidad operativa ni soporte.

Identificar escenarios regulados donde MLS puede aportar valor.

Revisar impacto de niveles sobre acceso a ficheros y procesos.

Documentar política de uso de categorías.

Diagnosticar denegaciones relacionadas con niveles.

Taller: analizar labels con categorías MCS en contenedores.

Usar `sestatus`, `getenforce`, `setenforce`, `ls -Z`, `ps -Z` y `id -Z`.

Usar `semanage` para ficheros, puertos, booleanos, usuarios, módulos y configuración persistente.

Usar `restorecon` para restaurar contextos correctos según política.

Usar `chcon` solo para cambios temporales o pruebas controladas.

Usar `matchpathcon` para consultar el contexto esperado de una ruta.

Usar `seinfo`, `sesearch` y herramientas de análisis cuando están disponibles.

Evitar cambios manuales sin persistencia ni documentación.

Crear alias y comandos de diagnóstico seguros para soporte.

Documentar comandos permitidos por nivel de soporte.

Taller: resolver cinco incidencias usando solo herramientas SELinux básicas.

Entender cómo SELinux asigna contextos por rutas mediante reglas de file context.

Crear reglas persistentes con `semanage fcontext`.

Aplicar cambios con `restorecon`.

Diferenciar `chcon` temporal de `semanage fcontext` persistente.

Evitar perder etiquetas correctas al mover datos o restaurar backups.

Gestionar rutas personalizadas para servicios web, bases de datos, logs y aplicaciones.

Consultar contexto esperado antes de cambiar etiquetas.

Documentar reglas locales de etiquetado.

Auditar ficheros con etiquetas inesperadas.

Taller: mover contenido web a ruta personalizada y etiquetarlo correctamente.

Entender cuándo es necesario relabel completo del sistema.

Preparar relabel tras reactivar SELinux, restaurar backup o corregir etiquetas masivas.

Usar mecanismos seguros como `fixfiles` o `.autorelabel` según distribución.

Evitar relabel en producción sin ventana, backup y estimación de impacto.

Detectar riesgos de downtime por relabel en sistemas grandes.

Revisar logs posteriores al relabel.

Validar servicios críticos tras completar la operación.

Documentar procedimiento y criterios de uso.

Automatizar comprobaciones posteriores.

Taller: simular sistema con etiquetas dañadas y recuperar etiquetado correcto.

Entender qué son los booleanos y cómo modifican comportamiento de política de forma controlada.

Listar booleanos con `getsebool` y `semanage boolean -l`.

Cambiar booleanos temporal y persistentemente con `setsebool`.

Evitar crear módulos de política cuando existe booleano oficial adecuado.

Revisar booleanos de servicios como httpd, samba, ftp, nfs, rsync o bases de datos.

Documentar booleanos modificados, motivo y owner.

Auditar booleanos que relajan seguridad más de lo necesario.

Validar efecto real de cada booleano.

Crear procedimiento de aprobación de booleanos en producción.

Taller: resolver incidencia web activando booleano correcto y justificando el cambio.

Entender cómo SELinux controla qué dominios pueden usar determinados puertos.

Consultar puertos etiquetados con `semanage port -l`.

Añadir puertos personalizados con `semanage port -a`.

Evitar cambiar una aplicación de puerto sin registrar el tipo SELinux adecuado.

Diferenciar puerto permitido por firewall y puerto permitido por SELinux.

Diagnosticar errores de bind causados por tipo de puerto incorrecto.

Documentar puertos no estándar por servicio.

Auditar puertos personalizados y su justificación.

Coordinar cambios de puerto con firewall, proxy y documentación.

Taller: configurar servicio web en puerto no estándar sin desactivar SELinux.

Localizar denegaciones SELinux en `/var/log/audit/audit.log` y logs del sistema.

Usar `ausearch` para filtrar AVC denials por proceso, tiempo, usuario o comando.

Interpretar campos clave: source context, target context, class, permission y comm.

Evitar tomar una denegación aislada sin contexto de operación.

Correlacionar denegaciones con hora, acción del usuario, servicio y despliegue.

Diferenciar denegaciones reales de ruido esperado.

Recoger evidencias antes de aplicar cambios.

Crear consultas reutilizables para soporte.

Documentar análisis y decisión tomada.

Taller: investigar caída de servicio con audit logs y encontrar causa raíz.

Usar `sealert` para obtener recomendaciones interpretables sobre denegaciones.

Entender cuándo la recomendación automática es suficiente y cuándo requiere revisión experta.

Evitar aplicar módulos generados automáticamente sin leer lo que permiten.

Revisar mensajes, plugins, probabilidad de causa y comandos sugeridos.

Relacionar salida de `sealert` con logs de auditoría.

Documentar hallazgos para soporte N1/N2.

Configurar herramientas de análisis en sistemas donde estén permitidas.

Gestionar entornos minimalistas sin setroubleshoot.

Crear criterio para escalar incidencias complejas.

Taller: resolver varias denegaciones comparando `ausearch` y `sealert`.

Entender qué hace `audit2allow` y por qué debe usarse con cuidado.

Generar reglas a partir de denegaciones de auditoría.

Revisar permisos propuestos antes de crear módulos.

Evitar convertir cualquier denegación en política permitida.

Diferenciar problema de etiquetado, booleano, puerto y necesidad real de nueva regla.

Crear módulo local mínimo y con nombre claro.

Instalar, listar, deshabilitar y eliminar módulos locales.

Documentar motivo, alcance, evidencia y fecha de revisión.

Revisar reglas excesivamente amplias.

Taller: crear política mínima para una aplicación interna tras descartar soluciones mejores.

Entender estructura de un módulo de política y su ciclo de vida.

Crear archivos `.te`, `.if`, `.fc` y paquetes de política cuando procede.

Compilar e instalar módulos con herramientas adecuadas.

Definir tipos, dominios, transiciones, permisos y file contexts.

Evitar módulos monolíticos que mezclan varias aplicaciones.

Versionar módulos en Git.

Probar módulos en permissive antes de producción.

Documentar dependencias y permisos concedidos.

Mantener proceso de revisión técnica.

Taller: construir módulo de política para servicio corporativo sencillo.

Leer reglas `allow`, `type`, `type_transition`, `file_type`, `domain_type` y macros comunes.

Entender permisos por clases: file, dir, tcp_socket, unix_stream_socket, process y capability.

Evitar escribir permisos por prueba y error sin comprender su alcance.

Usar macros de referencia cuando aportan claridad y mantenimiento.

Identificar permisos peligrosos o demasiado amplios.

Analizar reglas existentes con herramientas de consulta.

Separar política de ficheros, procesos, red y capabilities.

Documentar intención de cada bloque de política.

Revisar política con otro administrador antes de instalar.

Taller: leer una política SELinux y explicar qué permite realmente.

Diferenciar sistema permissive y dominio permissive.

Usar dominios permisivos para probar nuevas políticas sin relajar todo el sistema.

Evitar dejar dominios permisivos permanentemente sin justificación.

Listar, activar y retirar dominios permissive.

Recoger denegaciones durante pruebas controladas.

Convertir aprendizaje en política mínima.

Documentar caducidad y owner de dominios permisivos.

Integrar revisión de dominios permisivos en auditorías.

Crear alerta o control periódico.

Taller: poner dominio de aplicación en permissive, capturar denegaciones y endurecerlo.

Entender cómo systemd inicia servicios y cómo SELinux asigna dominios.

Revisar unit files, rutas de ejecutables, contextos y transiciones.

Evitar arrancar servicios personalizados desde rutas no etiquetadas.

Configurar servicios internos con etiquetas adecuadas.

Gestionar logs, PID files, sockets y directorios runtime.

Diagnosticar servicios que arrancan manualmente pero fallan con systemd.

Usar `systemctl`, `journalctl`, `ps -Z` y audit logs de forma coordinada.

Documentar requisitos SELinux de cada unidad.

Crear plantillas de despliegue seguras.

Taller: crear servicio systemd personalizado confinado por SELinux.

Administrar contextos para Apache, Nginx u otros servidores web.

Etiquetar contenido web, logs, uploads, CGI, scripts y directorios personalizados.

Configurar booleanos relacionados con conexiones de red, home directories, scripts y contenido dinámico.

Evitar poner contenido web en rutas arbitrarias sin file contexts persistentes.

Gestionar aplicaciones PHP, Python, Java o reverse proxies bajo política web.

Diagnosticar errores 403 causados por SELinux frente a permisos Unix.

Controlar escritura de aplicaciones en directorios específicos.

Documentar política web por aplicación.

Revisar exposición de ficheros sensibles.

Taller: desplegar aplicación web con contenido, logs y uploads bajo SELinux.

Revisar restricciones SELinux sobre SSH, usuarios, home directories y shells.

Diagnosticar problemas de login causados por etiquetas incorrectas en `.ssh`, home o authorized_keys.

Evitar corregir acceso remoto relajando permisos de forma insegura.

Configurar usuarios confinados y roles administrativos.

Gestionar acceso por sudo y transiciones de rol cuando procede.

Auditar intentos de acceso y denegaciones.

Documentar políticas de acceso remoto.

Integrar SELinux con hardening SSH.

Crear checklist de recuperación ante bloqueo de acceso.

Taller: resolver fallo de login SSH causado por contextos incorrectos.

Gestionar contextos de datos, logs, sockets y puertos de PostgreSQL, MariaDB/MySQL u otros servicios.

Mover data directories a rutas personalizadas con etiquetas persistentes.

Configurar puertos no estándar de forma segura.

Diagnosticar fallos de arranque por acceso a datadir, socket o logs.

Evitar desactivar SELinux durante migraciones de almacenamiento.

Gestionar backups y restores manteniendo etiquetas correctas.

Revisar booleanos y permisos relacionados con conexiones.

Documentar rutas y políticas de cada instancia.

Proteger ficheros sensibles de base de datos.

Taller: migrar directorio de datos de base de datos manteniendo SELinux enforcing.

Gestionar etiquetas en puntos de montaje locales, NFS, CIFS y almacenamiento compartido.

Revisar booleanos y tipos asociados a servicios de compartición.

Evitar montar almacenamiento sin revisar contextos y opciones.

Configurar contextos en mount options cuando procede.

Diagnosticar accesos denegados desde servicios que consumen almacenamiento compartido.

Gestionar backups, restores y migraciones de ficheros.

Documentar restricciones por protocolo y servicio.

Coordinar SELinux con permisos POSIX y ACLs.

Revisar riesgos de compartir directorios entre servicios.

Taller: configurar recurso NFS o Samba compatible con política SELinux.

Entender cómo SELinux refuerza el aislamiento de contenedores en hosts Linux.

Interpretar labels de procesos y ficheros asociados a contenedores.

Diferenciar aislamiento por namespaces, cgroups, capabilities, seccomp y SELinux.

Evitar montar volúmenes en contenedores sin etiquetado adecuado.

Usar opciones `:z` y `:Z` con criterio en bind mounts.

Diagnosticar errores de permission denied en Podman o Docker causados por SELinux.

Revisar diferencias entre rootless y rootful containers.

Controlar riesgos de `--privileged` y desactivación de labels.

Documentar patrones seguros de volúmenes.

Taller: desplegar contenedor con volumen persistente corrigiendo labels SELinux.

Analizar interacción entre Podman, contenedores rootless, usuarios, MCS y labels.

Gestionar volúmenes, permisos, user namespaces y contextos en rootless containers.

Evitar confundir permisos UID/GID con denegaciones SELinux.

Diagnosticar fallos con `podman unshare`, `ls -Z`, audit logs y contextos.

Aplicar `:U`, `:z`, `:Z` y estrategias de ownership cuando procede.

Revisar límites de usuarios confinados y contenedores rootless.

Documentar buenas prácticas para equipos DevOps.

Integrar SELinux con Quadlet y systemd de usuario.

Validar seguridad sin recurrir a `--privileged`.

Taller: operar servicio Podman rootless con volumen y SELinux enforcing.

Entender `udica` como herramienta para generar políticas SELinux adaptadas a contenedores.

Analizar cuándo una política generada por udica aporta más seguridad que tipos genéricos.

Crear política a partir de inspección de contenedor.

Revisar y ajustar la política generada antes de usarla.

Evitar confiar ciegamente en políticas automáticas.

Instalar, probar y retirar políticas de contenedor.

Documentar permisos necesarios por aplicación.

Integrar políticas con pipelines o despliegues controlados.

Comparar enfoque udica frente a etiquetas genéricas.

Taller: generar política SELinux para contenedor de aplicación interna.

Entender el papel de SELinux en plataformas basadas en contenedores como OpenShift.

Revisar cómo las plataformas gestionan MCS, SCC, permisos y contextos de pods.

Evitar usar privileged pods sin justificación y revisión de riesgo.

Diagnosticar problemas de volúmenes, hostPath, permisos y labels.

Relacionar SELinux con Security Context Constraints, Pod Security y políticas de cluster.

Diseñar workloads compatibles con ejecución restringida.

Coordinar equipos de plataforma, desarrollo y seguridad.

Documentar patrones aceptados de despliegue.

Revisar implicaciones en almacenamiento persistente.

Taller: analizar fallo de pod por permisos SELinux y corregir manifiesto.

Identificar aplicaciones corporativas que requieren política SELinux propia.

Definir procesos, rutas, puertos, sockets, logs, temporales y permisos necesarios.

Evitar ejecutar aplicaciones internas como unconfined por rapidez.

Crear tipos y dominios específicos para aplicaciones.

Etiquetar ficheros y directorios de forma persistente.

Usar dominios permissive para capturar comportamiento inicial.

Crear módulos mínimos y revisarlos.

Documentar runbook de despliegue SELinux de la aplicación.

Validar operación en enforcing.

Taller: confinar aplicación interna sencilla con política SELinux propia.

Automatizar modo SELinux, paquetes, booleanos, puertos, file contexts y restorecon.

Evitar playbooks que ejecutan `setenforce 0` como solución rápida.

Usar módulos Ansible adecuados para `sefcontext`, `seboolean`, `seport` y configuración.

Gestionar idempotencia en reglas SELinux.

Aplicar etiquetas tras desplegar ficheros o directorios.

Versionar reglas locales y módulos de política.

Crear validaciones post-despliegue.

Integrar auditoría de SELinux en pipelines de infraestructura.

Documentar cambios y excepciones.

Taller: crear playbook Ansible que despliega servicio con SELinux correctamente configurado.

Incorporar validaciones SELinux en pipelines de infraestructura y despliegue.

Probar políticas en entornos de staging antes de producción.

Versionar módulos, reglas fcontext, booleanos y puertos.

Evitar cambios manuales en servidores que no pasan por Git.

Crear pruebas automatizadas de acceso esperado y acceso bloqueado.

Generar artefactos de política revisables.

Documentar cambios en merge requests.

Integrar análisis de logs tras despliegue.

Crear rollback de políticas locales.

Taller: construir flujo GitOps/IaC para cambios SELinux controlados.

Crear inventario de sistemas con SELinux enforcing, permissive o disabled.

Auditar booleanos modificados, puertos personalizados, reglas fcontext y módulos locales.

Evitar excepciones permanentes sin owner ni fecha de revisión.

Recoger evidencias para auditoría de hardening y cumplimiento.

Integrar audit logs con SIEM o plataforma corporativa.

Revisar dominios unconfined y servicios críticos.

Documentar política de excepciones.

Crear informes periódicos de postura SELinux.

Relacionar SELinux con CIS, ISO 27001, ENS u otros marcos si aplican.

Taller: preparar informe audit-ready de configuración SELinux.

Centralizar AVC denials y eventos relevantes en SIEM.

Diferenciar eventos de troubleshooting, ruido esperado e indicadores de compromiso.

Evitar ignorar denegaciones que pueden revelar intento de abuso o proceso comprometido.

Crear alertas por denegaciones críticas en servicios sensibles.

Correlacionar eventos SELinux con logs de aplicación, sistema, EDR y red.

Definir retención y protección de logs de auditoría.

Crear dashboards de denegaciones por host, dominio, tipo y servicio.

Analizar tendencias tras cambios de despliegue.

Documentar procedimiento de investigación.

Taller: diseñar dashboard SIEM de eventos SELinux accionables.

Crear baseline de servidor Linux con SELinux enforcing.

Revisar servicios expuestos, contextos, booleanos, puertos, usuarios y módulos locales.

Evitar instalar software que requiere desactivar SELinux sin evaluación técnica.

Integrar SELinux con firewall, SSH, sudo, auditd, EDR y gestión de parches.

Crear checklist de hardening por rol de servidor.

Validar que servicios críticos funcionan bajo política confinada.

Reducir dominios unconfined cuando es viable.

Documentar excepciones y controles compensatorios.

Automatizar comprobaciones periódicas.

Taller: endurecer servidor web o base de datos manteniendo SELinux enforcing.

Usar eventos SELinux como fuente de evidencia durante incidentes.

Detectar comportamiento anómalo de procesos que intentan acceder a ficheros o puertos no permitidos.

Evitar eliminar logs o reiniciar sin recoger contexto.

Correlacionar denegaciones con timeline de incidente.

Analizar si la denegación bloqueó actividad maliciosa o reveló mala configuración.

Recoger contextos, procesos, hashes, comandos, usuarios y conexiones asociadas.

Documentar impacto de SELinux en contención.

Crear playbooks de respuesta ante denegaciones críticas.

Coordinar seguridad, sistemas, DevOps y aplicación.

Taller: investigar simulación de proceso comprometido bloqueado por SELinux.

Aplicar SELinux en VMs cloud, imágenes base, golden images y servidores autoscalables.

Evitar imágenes cloud con SELinux desactivado por defecto sin justificación.

Integrar reglas SELinux en bootstrap, cloud-init, Ansible e IaC.

Gestionar relabel tras crear imágenes o restaurar volúmenes.

Validar servicios tras autoescalado o sustitución de instancia.

Centralizar logs de auditoría en plataforma cloud o SIEM.

Documentar baseline cloud con SELinux enforcing.

Coordinar SELinux con security groups, firewalls, IAM y EDR.

Revisar impacto en workloads lift-and-shift.

Taller: preparar golden image cloud con SELinux activo y validaciones automáticas.

Evaluar sistemas con SELinux disabled o permissive.

Inventariar servicios, rutas, puertos, procesos, usuarios y dependencias.

Evitar pasar a enforcing sin capturar denegaciones y corregirlas.

Activar permissive temporalmente para observar comportamiento.

Corregir etiquetas, booleanos, puertos y políticas locales.

Planificar ventana de cambio y rollback.

Validar servicios críticos con pruebas funcionales.

Documentar excepciones y módulos creados.

Medir reducción de riesgo tras activar enforcing.

Taller: migrar servidor legacy de permissive a enforcing con plan controlado.

Entender el impacto de SELinux en rendimiento y por qué suele ser aceptable en entornos modernos.

Detectar situaciones con exceso de auditoría o políticas permisivas ruidosas.

Evitar culpar a SELinux de problemas de rendimiento sin medición.

Medir latencia de servicios antes y después de cambios relevantes.

Controlar tamaño de audit logs y rotación.

Ajustar logging y auditoría sin perder evidencia crítica.

Revisar impacto de contenedores, almacenamiento y políticas personalizadas.

Documentar resultados de pruebas.

Crear criterios para investigar overhead real.

Taller: medir impacto de SELinux en servicio web y analizar audit log bajo carga.

Definir qué debe saber soporte básico sobre SELinux.

Crear guías para no recomendar desactivación como primera respuesta.

Separar tareas N1, N2 y N3: detección, evidencias, análisis y creación de política.

Preparar comandos seguros para recogida de información.

Documentar escalado cuando aparece denegación compleja.

Crear base de conocimiento de incidencias recurrentes.

Formar a desarrollo sobre rutas, puertos, servicios y contenedores compatibles con SELinux.

Medir reducción de tickets por mejor documentación.

Mantener runbooks actualizados.

Taller: crear guía de soporte SELinux para Service Desk técnico.

Desactivar SELinux ante la primera denegación sin investigar causa raíz.

Usar `chmod 777` o cambiar owners cuando el problema es de contexto SELinux.

Aplicar `chcon` como solución permanente y perder el cambio tras relabel.

Instalar módulos generados por `audit2allow` sin revisar permisos concedidos.

Abrir booleanos o puertos sin documentar motivo, owner y fecha de revisión.

Ejecutar contenedores con `--privileged` para evitar problemas de labels.

Ignorar denegaciones que pueden indicar comportamiento malicioso.

Mantener dominios permissive durante meses.

No incluir reglas SELinux en automatización de despliegue.

Taller: auditar servidor lleno de malas prácticas SELinux y corregirlo con criterio.

Evaluar madurez actual: enforcing, permissive, disabled, políticas, automatización, soporte, logs y formación.

Identificar quick wins: activar audit, corregir labels, eliminar `disabled`, revisar booleanos y centralizar denegaciones.

Priorizar sistemas por criticidad, exposición, datos tratados, cumplimiento y facilidad de corrección.

Definir baseline SELinux para servidores web, bases de datos, contenedores, cloud y sistemas internos.

Crear piloto con servicios representativos y owners comprometidos.

Establecer proceso de cambios: fcontext, booleanos, puertos, módulos y revisiones.

Formar a sistemas, DevOps, seguridad y desarrollo.

Medir reducción de excepciones, dominios permissive y sistemas sin enforcing.

Crear plan a 30, 60, 90 y 180 días.

Taller: construir roadmap SELinux para una organización con 200 servidores Linux.

Definir una organización con servidores Linux, servicios web, bases de datos, contenedores, usuarios, auditoría y requisitos de hardening.

Preparar baseline SELinux con modo enforcing, paquetes necesarios, audit logs, herramientas de diagnóstico y configuración inicial.

Desplegar servicio web con contenido en ruta personalizada, puerto no estándar, logs, uploads y permisos controlados.

Corregir etiquetas persistentes con `semanage fcontext` y `restorecon`, documentando por qué no se usa `chcon` permanente.

Configurar booleanos y puertos necesarios con justificación, evidencia, owner y fecha de revisión.

Diagnosticar denegaciones con `ausearch`, `sealert` y logs, separando problemas de labels, puertos, booleanos y política.

Crear módulo local mínimo para una aplicación interna tras validar que no existe solución oficial más segura.

Desplegar contenedor Podman con volumen persistente y labels SELinux correctos sin usar `--privileged`.

Automatizar configuración con Ansible o scripts idempotentes, incluyendo validaciones y rollback.

Presentar solución final con runbooks, checklist de hardening, matriz de excepciones, auditoría, SIEM, riesgos y roadmap.