OpenSCAP es la implementación de código abierto del estándar SCAP (Security Content Automation Protocol). Su escáner, oscap, evalúa un sistema contra un perfil de seguridad escrito en XCCDF/OVAL, como el CIS Benchmark o el DISA-STIG, y genera un informe con cada regla aprobada o fallida. En este tutorial instalarás OpenSCAP en Ubuntu 24.04, descargarás el contenido de SCAP Security Guide, lanzarás un escaneo CIS, generarás la remediación, comprobarás vulnerabilidades conocidas con los datos OVAL de Canonical y programarás un escaneo semanal.

Requisitos previos

  • Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
  • Un usuario no root con privilegios sudo.
  • Unos 500 MB libres en disco para el contenido SCAP y los informes.
  • Acceso a internet desde el servidor para descargar el contenido.

Paso 1: Instalar el escáner

El escáner está en el repositorio universe de Ubuntu:

sudo apt update
sudo apt install openscap-scanner unzip

Comprueba la versión:

oscap --version | head -n 1

OpenSCAP command line tool (oscap) 1.3.9

Ubuntu 24.04 también trae los paquetes ssg-* con contenido SCAP, pero su versión (0.1.71) solo incluye data streams hasta Ubuntu 22.04. Por eso descargarás el contenido directamente del proyecto ComplianceAsCode en el paso siguiente.

Paso 2: Descargar SCAP Security Guide

SCAP Security Guide (SSG) es el contenido que define las reglas y perfiles. Consulta la última versión en la página de releases de github.com/ComplianceAsCode/content y guárdala en una variable. En el momento de escribir esta guía es la 0.1.82:

SSG_VERSION=0.1.82
cd /tmp
wget "https://github.com/ComplianceAsCode/content/releases/download/v${SSG_VERSION}/scap-security-guide-${SSG_VERSION}.zip"
wget "https://github.com/ComplianceAsCode/content/releases/download/v${SSG_VERSION}/scap-security-guide-${SSG_VERSION}.zip.sha512"

Verifica la integridad del fichero descargado:

sha512sum -c "scap-security-guide-${SSG_VERSION}.zip.sha512"

scap-security-guide-0.1.82.zip: OK

Extrae solo el data stream de Ubuntu 24.04 en /usr/local/share/scap:

sudo mkdir -p /usr/local/share/scap
sudo unzip -j -o "scap-security-guide-${SSG_VERSION}.zip" "*/ssg-ubuntu2404-ds.xml" -d /usr/local/share/scap
ls /usr/local/share/scap

ssg-ubuntu2404-ds.xml

Para no repetir la ruta en cada comando, guárdala en una variable de la sesión:

DS=/usr/local/share/scap/ssg-ubuntu2404-ds.xml

Paso 3: Ver los perfiles disponibles

Un data stream contiene varios perfiles. Lístalos:

oscap info --profiles "$DS"

xccdf_org.ssgproject.content_profile_cis_level1_server:CIS Ubuntu 24.04 Level 1 Server Benchmark
xccdf_org.ssgproject.content_profile_cis_level1_workstation:CIS Ubuntu 24.04 Level 1 Workstation Benchmark
xccdf_org.ssgproject.content_profile_cis_level2_server:CIS Ubuntu 24.04 Level 2 Server Benchmark
xccdf_org.ssgproject.content_profile_cis_level2_workstation:CIS Ubuntu 24.04 Level 2 Workstation Benchmark
xccdf_org.ssgproject.content_profile_stig:...

La parte anterior a los dos puntos es el ID del perfil. Si quieres leer qué comprueba cada regla antes de escanear, genera la guía del perfil en HTML:

oscap xccdf generate guide \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  "$DS" > ~/guia-cis-l1.html

Paso 4: Lanzar un escaneo CIS

Crea un directorio para los resultados y lanza la evaluación con sudo, porque muchas reglas leen ficheros que solo root puede ver:

sudo mkdir -p /var/lib/oscap
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  --results-arf /var/lib/oscap/arf-cis-l1.xml \
  --report /var/lib/oscap/informe-cis-l1.html \
  "$DS"

Durante el escaneo verás cada regla con su resultado:

Title   Ensure SSH root login is disabled
Rule    xccdf_org.ssgproject.content_rule_sshd_disable_root_login
Ident   CCE-...
Result  pass

Title   Ensure auditd service is enabled
Rule    xccdf_org.ssgproject.content_rule_service_auditd_enabled
Result  fail

El código de salida indica el resultado global: 0 si todas las reglas pasan, 2 si alguna falla y 1 si hubo un error en la evaluación. Que termine con 2 es lo normal en un primer escaneo.

Cuenta las reglas por resultado:

sudo grep -o 'result>[a-z]*</' /var/lib/oscap/arf-cis-l1.xml | sort | uniq -c

    142 result>fail</
     18 result>notapplicable</
     96 result>pass</

Copia el informe HTML a tu equipo para abrirlo en el navegador. Muestra la puntuación, las reglas fallidas agrupadas por severidad y, en cada una, la justificación y la forma de corregirla:

sudo cp /var/lib/oscap/informe-cis-l1.html ~ && sudo chown "$USER" ~/informe-cis-l1.html

scp your_user@your_server_ip:informe-cis-l1.html .

Para comprobar una sola regla (por ejemplo, tras corregirla), usa --rule:

sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  --rule xccdf_org.ssgproject.content_rule_sshd_disable_root_login \
  "$DS"

Paso 5: Generar la remediación

OpenSCAP puede generar, a partir de los resultados, un script o un playbook que corrige solo las reglas que fallaron. El ID del resultado se forma con el prefijo xccdf_org.open-scap_testresult_ seguido del ID del perfil.

Como script de Bash:

sudo oscap xccdf generate fix \
  --fix-type bash \
  --result-id xccdf_org.open-scap_testresult_xccdf_org.ssgproject.content_profile_cis_level1_server \
  --output /var/lib/oscap/remediacion-cis-l1.sh \
  /var/lib/oscap/arf-cis-l1.xml

O como playbook de Ansible, más cómodo si gestionas varios servidores:

sudo oscap xccdf generate fix \
  --fix-type ansible \
  --result-id xccdf_org.open-scap_testresult_xccdf_org.ssgproject.content_profile_cis_level1_server \
  --output /var/lib/oscap/remediacion-cis-l1.yml \
  /var/lib/oscap/arf-cis-l1.xml

Revisa el script y, cuando estés conforme, ejecútalo guardando la salida:

sudo less /var/lib/oscap/remediacion-cis-l1.sh
sudo bash /var/lib/oscap/remediacion-cis-l1.sh 2>&1 | sudo tee /var/lib/oscap/remediacion.log

Reinicia el servidor y repite el escaneo del paso 4 con otros nombres de fichero. El número de reglas en fail debería bajar considerablemente; las que queden suelen necesitar decisiones manuales, como particiones separadas.

Paso 6: Buscar vulnerabilidades conocidas con OVAL

Además de configuración, OpenSCAP evalúa definiciones OVAL de vulnerabilidades. Canonical publica una para cada versión de Ubuntu, con todos sus avisos de seguridad (USN):

cd /tmp
wget https://security-metadata.canonical.com/oval/com.ubuntu.noble.usn.oval.xml.bz2
bunzip2 -f com.ubuntu.noble.usn.oval.xml.bz2

Evalúa el sistema y genera el informe:

oscap oval eval \
  --report /var/lib/oscap/informe-usn.html \
  com.ubuntu.noble.usn.oval.xml

En la salida, cada definición con resultado true es un aviso de seguridad cuyo parche no está instalado:

oscap oval eval com.ubuntu.noble.usn.oval.xml | grep -c ': true'

3

Si el número es mayor que cero, sudo apt update && sudo apt upgrade suele resolverlo. Descarga el fichero OVAL de nuevo antes de cada escaneo, ya que se actualiza a diario.

Paso 7: Programar un escaneo semanal

Un escaneo aislado solo dice cómo estaba el sistema ese día. Programar uno semanal te permite detectar desviaciones, por ejemplo cuando alguien reactiva el acceso root por SSH.

Crea el script:

sudo nano /usr/local/sbin/oscap-weekly

#!/usr/bin/env bash
set -euo pipefail

ds="/usr/local/share/scap/ssg-ubuntu2404-ds.xml"
profile="xccdf_org.ssgproject.content_profile_cis_level1_server"
outdir="/var/lib/oscap/$(date +%F)"
mkdir -p "$outdir"

rc=0
oscap xccdf eval \
  --profile "$profile" \
  --results-arf "$outdir/arf.xml" \
  --report "$outdir/informe.html" \
  "$ds" > "$outdir/salida.txt" 2>&1 || rc=$?

# 0 = todo correcto, 2 = alguna regla falla; cualquier otro código es un error
if [ "$rc" -ne 0 ] && [ "$rc" -ne 2 ]; then
  echo "oscap terminó con error (código $rc), revisa $outdir/salida.txt" >&2
  exit "$rc"
fi

fails=$(grep -o 'result>fail</' "$outdir/arf.xml" | wc -l)
echo "Escaneo CIS L1 en $(hostname): $fails reglas fallidas. Informe: $outdir/informe.html"

# Conserva solo los últimos 12 escaneos
find /var/lib/oscap -mindepth 1 -maxdepth 1 -type d -name '20*' | sort | head -n -12 | xargs -r rm -rf

Hazlo ejecutable y pruébalo:

sudo chmod 750 /usr/local/sbin/oscap-weekly
sudo /usr/local/sbin/oscap-weekly

Escaneo CIS L1 en web01: 37 reglas fallidas. Informe: /var/lib/oscap/2026-09-25/informe.html

Crea el servicio de systemd:

sudo nano /etc/systemd/system/oscap-weekly.service

[Unit]
Description=Escaneo semanal de cumplimiento con OpenSCAP

[Service]
Type=oneshot
ExecStart=/usr/local/sbin/oscap-weekly
Nice=10
IOSchedulingClass=idle

Y el temporizador, para los domingos a las 03:00:

sudo nano /etc/systemd/system/oscap-weekly.timer

[Unit]
Description=Ejecuta el escaneo de OpenSCAP cada semana

[Timer]
OnCalendar=Sun *-*-* 03:00:00
Persistent=true

[Install]
WantedBy=timers.target

Actívalo y comprueba la próxima ejecución:

sudo systemctl daemon-reload
sudo systemctl enable --now oscap-weekly.timer
systemctl list-timers oscap-weekly.timer

El resumen de cada ejecución queda en el journal, desde donde puedes enviarlo a tu sistema de alertas:

journalctl -u oscap-weekly.service -n 5

Solución de problemas

oscap termina con código 1 y un error al cargar el data stream. Comprueba la ruta con ls -l "$DS" y que el fichero no esté truncado repitiendo la verificación sha512sum -c. Si usas una versión de SSG muy reciente, algunos contenidos pueden requerir una versión de OpenSCAP posterior a la 1.3.9; prueba con la release anterior de SSG.

Muchas reglas aparecen como error o notchecked. Asegúrate de ejecutar el escaneo con sudo. Las reglas notchecked no tienen comprobación automática y hay que revisarlas a mano.

El playbook o el script falla en una regla concreta. Localiza la regla en el informe HTML, revisa su bloque en el script y corrígela manualmente o exclúyela, documentando el motivo.

El escaneo tarda mucho. El perfil completo puede tardar varios minutos en servidores con muchos ficheros, porque algunas reglas recorren el sistema de archivos buscando permisos. Por eso el servicio usa Nice y prioridad de E/S baja.

Conclusión

Has instalado OpenSCAP en Ubuntu 24.04, evaluado el sistema contra el perfil CIS Level 1 Server de SCAP Security Guide, generado la remediación en Bash y Ansible, comprobado vulnerabilidades pendientes con el OVAL de Canonical y programado un escaneo semanal. Como siguientes pasos, prueba el perfil STIG o el CIS Level 2 en un servidor de pruebas, guarda los informes fuera del servidor como evidencia de auditoría y aplica la remediación de Ansible a todo tu inventario.