Compliance & Auditing 18 min leestijd

Linux Security Auditing met Lynis en OpenSCAP

Leer hoe je met Lynis en OpenSCAP geautomatiseerde beveiligingsaudits uitvoert op Linux-servers. Praktische gids met CIS Benchmark-scanning, automatische remediatie, compliance-rapportage en CI/CD-integratie — met werkende voorbeelden voor Ubuntu 24.04 en RHEL 9.

Editorial Team

Waarom geautomatiseerde beveiligingsaudits onmisbaar zijn in 2026

Je hebt je Linux-servers gehardend. SSH is dichtgetimmerd, de firewall staat strak, SELinux draait in enforcing mode en je containers zijn rootless. Mooi. Maar hoe weet je zeker dat alles ook morgen nog goed geconfigureerd is? Configuratiedrift is een van de meest onderschatte beveiligingsrisico's — en eerlijk gezegd is het ook een van de meest frustrerende. Eén verkeerde wijziging door een collega, een package-update die stilletjes instellingen overschrijft, of een snelle hotfix die nooit is teruggedraaid. En plotseling staat je zorgvuldig gehardende server weer wagenwijd open.

Ik heb dit zelf meegemaakt bij een klant: drie maanden na een grondige hardening-sessie bleek een automatische kernel-update de sysctl-instellingen gedeeltelijk te hebben overschreven. Niemand had het gemerkt. Dat is precies waar geautomatiseerde beveiligingsaudits het verschil maken. Met tools als Lynis en OpenSCAP kun je je systemen continu toetsen aan bewezen beveiligingsstandaarden zoals de CIS Benchmarks, PCI DSS en DISA STIG. En met de CIS Benchmark-updates van maart 2026 — die diepere kernel-hardening, strengere container-runtime-configuraties en uitgebreidere bestandsintegriteitsmonitoring bevatten — is het belangrijker dan ooit om je auditing-toolchain op orde te hebben.

In deze gids laat ik je stap voor stap zien hoe je Lynis en OpenSCAP installeert, configureert en integreert in een geautomatiseerde compliance-workflow. Alle voorbeelden zijn getest op Ubuntu 24.04 LTS en RHEL 9, en zijn direct toepasbaar in productie.

Lynis: snelle beveiligingsaudits voor elke Linux-server

Wat is Lynis en hoe werkt het?

Lynis bestaat al sinds 2007 en wordt actief onderhouden door CISOfy. Het is een open-source beveiligingsaudit-tool die meer dan 300 individuele tests uitvoert op je systeem — van authenticatieconfiguratie en bestandspermissies tot kernel-hardening, netwerkdiensten en software-kwetsbaarheden. Het resultaat is een hardening index score tussen 0 en 100, plus concrete aanbevelingen om je score te verbeteren. Simpel, maar verrassend effectief.

Wat Lynis bijzonder maakt, is dat het agentless werkt. Geen daemon, geen agent, geen gedoe — het is gewoon een shellscript dat je lokaal uitvoert. De nieuwste versie is Lynis 3.1.6, met ondersteuning voor de nieuwste Linux-distributies en verbeterde detectie van beveiligingssoftware.

Lynis installeren

Lynis is beschikbaar via de standaard packagemanagers van de meeste distributies, maar eerlijk gezegd loopt die versie vaak achter. Voor de meest actuele versie gebruik je het CISOfy-repository:

# Optie 1: Installatie via de standaard packagemanager
# Ubuntu/Debian
sudo apt update && sudo apt install -y lynis

# RHEL 9 / AlmaLinux 9 / Rocky Linux 9
sudo dnf install -y lynis

# Optie 2: Installatie via het CISOfy-repository (aanbevolen)
# Voeg de CISOfy GPG-sleutel toe
sudo wget -O - https://packages.cisofy.com/keys/cisofy-software-public.key | sudo apt-key add -

# Voeg het repository toe (Ubuntu/Debian)
echo "deb https://packages.cisofy.com/community/lynis/deb/ stable main" | sudo tee /etc/apt/sources.list.d/cisofy-lynis.list

sudo apt update && sudo apt install -y lynis

# Optie 3: Direct van GitHub (altijd de nieuwste versie)
cd /opt
sudo git clone https://github.com/CISOfy/lynis.git
cd lynis
sudo ./lynis audit system

# Controleer de versie
lynis --version
# Verwachte output: 3.1.6

Je eerste beveiligingsaudit uitvoeren

Het uitvoeren van een Lynis-audit is eenvoudig. Er zijn wel een paar valkuilen waar je op moet letten, maar die behandel ik zo.

# Voer een volledige systeemaudit uit (altijd als root!)
sudo lynis audit system

# Waarom root? Lynis slaat veel geprivilegieerde tests over
# als je het als normale gebruiker draait. Je score wordt
# kunstmatig laag en onbetrouwbaar.

# Voor een beknoptere output (handig voor scripting):
sudo lynis audit system --quick

# Bekijk het gedetailleerde rapport:
sudo cat /var/log/lynis-report.dat

# Bekijk alleen de waarschuwingen en suggesties:
sudo grep -E "^warning|^suggestion" /var/log/lynis-report.dat

De Lynis-output interpreteren

Na een audit krijg je drie categorieën resultaten. Oké, nu wordt het interessant:

  • Waarschuwingen (Warnings) — Kritieke problemen die directe aandacht vereisen. Denk aan kwetsbare softwarepakketten, een inactieve firewall of ontbrekende tijdsynchronisatie.
  • Suggesties (Suggestions) — Aanbevolen verbeteringen die je beveiliging versterken maar niet acuut kritiek zijn. Bijvoorbeeld het installeren van fail2ban, het aanscherpen van SSH-configuratie of het implementeren van bestandsintegriteitsmonitoring.
  • Hardening Index — Een score van 0 tot 100. Een verse standaardinstallatie scoort doorgaans 55-65. Voor productieservers wil je op 80 of hoger zitten (en nee, 100 is geen realistisch doel — daar kom ik later op terug).

Van 60 naar 80+: de hoogste-impact verbeteringen

Met vier gerichte aanpassingen kun je je score doorgaans met 15-20 punten verhogen. In mijn ervaring leveren deze stappen veruit het meeste op per bestede minuut:

# 1. SSH root-login uitschakelen (als je dat nog niet hebt gedaan)
sudo sed -i 's/^#*PermitRootLogin.*/PermitRootLogin no/' /etc/ssh/sshd_config
sudo sed -i 's/^#*MaxAuthTries.*/MaxAuthTries 3/' /etc/ssh/sshd_config
sudo systemctl restart sshd

# 2. Firewall inschakelen met actieve regels
sudo ufw enable
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw status verbose

# 3. Auditd installeren en activeren
sudo apt install -y auditd audispd-plugins  # Ubuntu/Debian
# OF: sudo dnf install -y audit              # RHEL
sudo systemctl enable --now auditd

# 4. Kernel-hardening via sysctl
cat <<EOF | sudo tee /etc/sysctl.d/99-security-hardening.conf
# Netwerk hardening
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1
net.ipv4.tcp_syncookies = 1
net.ipv4.icmp_echo_ignore_broadcasts = 1

# Kernel hardening
kernel.randomize_va_space = 2
kernel.dmesg_restrict = 1
kernel.kptr_restrict = 2
kernel.yama.ptrace_scope = 1
fs.protected_hardlinks = 1
fs.protected_symlinks = 1
fs.suid_dumpable = 0
EOF

sudo sysctl --system

# Draai Lynis opnieuw om je nieuwe score te zien
sudo lynis audit system

Lynis-audits automatiseren met cron

Een eenmalige audit is nuttig, maar de echte waarde zit in continu monitoren. Serieus — een audit die je één keer per kwartaal draait heeft bijna geen waarde. Configureer een dagelijkse of wekelijkse cron-job en laat het systeem het werk voor je doen:

# Maak een directory voor compliance-rapporten
sudo mkdir -p /var/log/compliance/lynis

# Maak een audit-script
cat <<'SCRIPT' | sudo tee /usr/local/bin/lynis-daily-audit.sh
#!/bin/bash
DATUM=$(date +%Y-%m-%d_%H%M)
RAPPORTDIR="/var/log/compliance/lynis"

# Voer de audit uit in cronjob-modus (geen interactieve output)
lynis audit system --cronjob --quiet \
  --logfile "${RAPPORTDIR}/lynis-${DATUM}.log" \
  --report-file "${RAPPORTDIR}/lynis-report-${DATUM}.dat"

# Extraheer de hardening index
SCORE=$(grep "hardening_index=" "${RAPPORTDIR}/lynis-report-${DATUM}.dat" | cut -d= -f2)

# Stuur een waarschuwing als de score onder de 75 zakt
if [ "$SCORE" -lt 75 ] 2>/dev/null; then
  echo "WAARSCHUWING: Lynis hardening score is ${SCORE} op $(hostname)" | \
    mail -s "Lynis Alert: Score onder drempel" [email protected]
fi

# Bewaar rapporten maximaal 90 dagen
find "${RAPPORTDIR}" -name "lynis-*" -mtime +90 -delete
SCRIPT

sudo chmod +x /usr/local/bin/lynis-daily-audit.sh

# Voeg toe aan crontab (dagelijks om 03:00)
echo "0 3 * * * root /usr/local/bin/lynis-daily-audit.sh" | sudo tee /etc/cron.d/lynis-audit

OpenSCAP: compliance-scanning tegen formele standaarden

Wat is OpenSCAP en wanneer gebruik je het?

Terwijl Lynis een breed scala aan beveiligingschecks uitvoert op basis van best practices, richt OpenSCAP zich op formele compliance-standaarden. OpenSCAP is de open-source referentie-implementatie van het Security Content Automation Protocol (SCAP) — een NIST-standaard voor geautomatiseerde kwetsbaarheidsscanning en compliance-controle. Klinkt droog, maar het is ontzettend krachtig als je het eenmaal doorhebt.

De kracht van OpenSCAP zit in de SCAP Security Guide (SSG): een verzameling machine-leesbare beveiligingsprofielen afgeleid van erkende standaarden zoals CIS Benchmarks, DISA STIG, PCI DSS en HIPAA. Je kunt je systeem hiermee scannen, een gedetailleerd HTML-rapport genereren en zelfs automatisch remediëren. Dat laatste is indrukwekkend — maar ook iets om voorzichtig mee te zijn (meer daarover verderop).

Gebruik OpenSCAP wanneer je:

  • Moet voldoen aan specifieke compliance-frameworks (CIS, STIG, PCI DSS)
  • Auditrapporten moet genereren voor interne of externe auditors
  • Automatische remediatie wilt toepassen op basis van een profiel
  • Compliance wilt integreren in je CI/CD- of provisioningpipeline

OpenSCAP installeren

# Ubuntu 24.04 LTS
sudo apt update
sudo apt install -y libopenscap8 openscap-scanner openscap-utils

# Installeer de SCAP Security Guide (beveiligingsprofielen)
sudo apt install -y ssg-base ssg-debderived ssg-ubuntu

# RHEL 9 / AlmaLinux 9 / Rocky Linux 9
sudo dnf install -y openscap-scanner scap-security-guide openscap-utils

# Controleer de installatie
oscap --version

# Bekijk waar de beveiligingsprofielen staan
ls /usr/share/xml/scap/ssg/content/

Beschikbare profielen verkennen

Voordat je een scan uitvoert, is het slim om eerst te bekijken welke profielen beschikbaar zijn voor jouw distributie. Dat scheelt zoeken achteraf:

# Bekijk beschikbare profielen voor Ubuntu 24.04
oscap info /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml

# Voor RHEL 9:
oscap info /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Typische beschikbare profielen:
# - cis_level1_server      (CIS Level 1 — Server)
# - cis_level1_workstation (CIS Level 1 — Werkstation)
# - cis_level2_server      (CIS Level 2 — Server)
# - cis_level2_workstation (CIS Level 2 — Werkstation)
# - stig                   (DISA STIG)
# - pci-dss                (PCI DSS)
# - standard               (Basis beveiligingsprofiel)

Een CIS Benchmark-scan uitvoeren

Dus, laten we een volledige CIS Level 1 Server-scan uitvoeren en een HTML-rapport genereren. Het commando ziet er wat lang uit, maar het is eigenlijk heel recht-toe-recht-aan:

# Maak een directory voor rapporten
sudo mkdir -p /var/log/compliance/openscap

# Voer een CIS Level 1 Server-scan uit (Ubuntu 24.04)
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  --results /var/log/compliance/openscap/cis-results.xml \
  --report /var/log/compliance/openscap/cis-rapport.html \
  /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml

# Voor RHEL 9:
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  --results /var/log/compliance/openscap/cis-results.xml \
  --report /var/log/compliance/openscap/cis-rapport.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Open het HTML-rapport in je browser
# Het rapport toont per regel: pass, fail, notapplicable of error

Het OpenSCAP-rapport interpreteren

Het gegenereerde HTML-rapport is uitstekend geschikt om met auditors en management te delen — en geloof me, ze zijn altijd onder de indruk van zo'n overzichtelijk rapport. Het bevat:

  • Score-samenvatting — Percentage geslaagde regels ten opzichte van het totaal
  • Per-regel resultaten — Elke CIS-aanbeveling met de status pass, fail of not applicable
  • Beschrijvingen — Waarom elke regel belangrijk is en wat het beveiligingsrisico is
  • Remediatie-instructies — Specifieke commando's om gefaalde regels te verhelpen

Automatische remediatie met OpenSCAP

Een van de krachtigste functies van OpenSCAP is automatische remediatie. Je kunt het systeem direct laten repareren, of — wat ik altijd aanraad — eerst een script laten genereren dat je kunt reviewen voordat er iets verandert:

# Optie 1: Online remediatie (scan + fix in één stap)
# LET OP: Test dit altijd eerst op een staging-server!
sudo oscap xccdf eval --remediate \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  --results /var/log/compliance/openscap/remediation-results.xml \
  --report /var/log/compliance/openscap/remediation-rapport.html \
  /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml

# Optie 2: Genereer een Bash-script voor handmatige review
sudo oscap xccdf generate fix \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  --fix-type bash \
  --output /var/log/compliance/openscap/remediation.sh \
  /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml

# Bekijk het script voordat je het uitvoert
less /var/log/compliance/openscap/remediation.sh

# Optie 3: Genereer een Ansible Playbook
sudo oscap xccdf generate fix \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  --fix-type ansible \
  --output /var/log/compliance/openscap/remediation-playbook.yml \
  /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml

# Pas het playbook toe met Ansible
ansible-playbook -i localhost, -c local /var/log/compliance/openscap/remediation-playbook.yml

Belangrijk: voer automatische remediatie nooit rechtstreeks uit op productiesystemen zonder het eerst te testen. Niet alle regels hebben geautomatiseerde fixes, en sommige wijzigingen kunnen services verstoren of herstarts vereisen die je niet verwacht.

Lynis en OpenSCAP combineren voor maximale dekking

Waarom je beide tools nodig hebt

Lynis en OpenSCAP zijn complementair, niet concurrerend. Ik zie regelmatig teams die één van beide gebruiken en denken dat ze klaar zijn — maar dat klopt niet. Dit is hoe ze zich tot elkaar verhouden:

  • Lynis is breed en pragmatisch — het controleert meer dan 300 punten op basis van best practices en geeft je een snelle indicatie van je beveiligingsniveau. Het is ideaal voor dagelijkse checks en het ontdekken van onverwachte configuratiewijzigingen.
  • OpenSCAP is diep en formeel — het toetst je systeem tegen specifieke compliance-frameworks met machine-leesbare resultaten. Het is onmisbaar voor auditdoeleinden en formele compliance-eisen.

Door beide te combineren krijg je het beste van twee werelden: brede dekking voor dagelijkse operationele beveiliging én formele compliance-rapportage voor auditors.

Een geïntegreerde compliance-workflow opzetten

#!/bin/bash
# compliance-scan.sh — Geïntegreerde Lynis + OpenSCAP compliance-scan
# Gebruik: sudo ./compliance-scan.sh [cis_level1_server|cis_level2_server|stig]

set -euo pipefail

PROFIEL="${1:-cis_level1_server}"
DATUM=$(date +%Y-%m-%d_%H%M)
BASEDIR="/var/log/compliance"
LYNIS_DIR="${BASEDIR}/lynis"
OSCAP_DIR="${BASEDIR}/openscap"
SAMENVATTING="${BASEDIR}/samenvatting-${DATUM}.txt"

# Detecteer de distributie en kies het juiste SSG-bestand
if [ -f /etc/os-release ]; then
  . /etc/os-release
  case "$ID" in
    ubuntu)
      SSG_FILE="/usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml"
      ;;
    rhel|almalinux|rocky)
      SSG_FILE="/usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml"
      ;;
    *)
      echo "Distributie $ID wordt niet ondersteund door dit script."
      exit 1
      ;;
  esac
fi

mkdir -p "$LYNIS_DIR" "$OSCAP_DIR"

echo "=== Compliance Scan Gestart: $(date) ===" | tee "$SAMENVATTING"
echo "Profiel: $PROFIEL" | tee -a "$SAMENVATTING"
echo "" | tee -a "$SAMENVATTING"

# Stap 1: Lynis-audit
echo "--- Lynis Audit ---" | tee -a "$SAMENVATTING"
lynis audit system --cronjob --quiet \
  --logfile "${LYNIS_DIR}/lynis-${DATUM}.log" \
  --report-file "${LYNIS_DIR}/lynis-report-${DATUM}.dat"

LYNIS_SCORE=$(grep "hardening_index=" "${LYNIS_DIR}/lynis-report-${DATUM}.dat" | cut -d= -f2)
LYNIS_WARNINGS=$(grep -c "^warning\[\]=" "${LYNIS_DIR}/lynis-report-${DATUM}.dat" || true)
echo "Lynis Hardening Index: ${LYNIS_SCORE}/100" | tee -a "$SAMENVATTING"
echo "Lynis Waarschuwingen: ${LYNIS_WARNINGS}" | tee -a "$SAMENVATTING"
echo "" | tee -a "$SAMENVATTING"

# Stap 2: OpenSCAP-scan
echo "--- OpenSCAP Scan (${PROFIEL}) ---" | tee -a "$SAMENVATTING"
oscap xccdf eval \
  --profile "xccdf_org.ssgproject.content_profile_${PROFIEL}" \
  --results "${OSCAP_DIR}/results-${DATUM}.xml" \
  --report "${OSCAP_DIR}/rapport-${DATUM}.html" \
  "$SSG_FILE" 2>&1 || true

# Extraheer OpenSCAP-resultaten
PASS=$(grep -c 'result="pass"' "${OSCAP_DIR}/results-${DATUM}.xml" || echo "0")
FAIL=$(grep -c 'result="fail"' "${OSCAP_DIR}/results-${DATUM}.xml" || echo "0")
TOTAAL=$((PASS + FAIL))
if [ "$TOTAAL" -gt 0 ]; then
  PERCENTAGE=$((PASS * 100 / TOTAAL))
else
  PERCENTAGE=0
fi

echo "OpenSCAP Geslaagd: ${PASS}/${TOTAAL} (${PERCENTAGE}%)" | tee -a "$SAMENVATTING"
echo "OpenSCAP Gefaald: ${FAIL}" | tee -a "$SAMENVATTING"
echo "" | tee -a "$SAMENVATTING"

# Stap 3: Samenvatting
echo "=== Scan Voltooid: $(date) ===" | tee -a "$SAMENVATTING"
echo "Rapporten beschikbaar in: ${BASEDIR}" | tee -a "$SAMENVATTING"

# Optioneel: stuur samenvatting per e-mail
# mail -s "Compliance Rapport $(hostname) - ${DATUM}" [email protected] < "$SAMENVATTING"

SCAP Workbench: een grafische interface voor OpenSCAP

Niet iedereen wil alles via de commandoregel doen, en dat is prima. Als je liever met een grafische interface werkt — of als je auditors een gebruiksvriendelijke tool wilt geven zonder ze te overstelpen met terminalsessies — is SCAP Workbench een uitstekende optie. Het is een desktopapplicatie waarmee je beveiligingsprofielen kunt laden, aanpassen en scans kunt uitvoeren.

# Installeer SCAP Workbench
# Ubuntu/Debian
sudo apt install -y scap-workbench

# RHEL 9
sudo dnf install -y scap-workbench

# Start de applicatie
scap-workbench &

Met SCAP Workbench kun je:

  • Profielen visueel verkennen en individuele regels in- of uitschakelen
  • Aangepaste profielen (tailoring-bestanden) maken voor je specifieke omgeving
  • Scans uitvoeren en resultaten direct bekijken
  • HTML- en XML-rapporten exporteren

Profielen aanpassen met tailoring

Standaardprofielen zijn een goed startpunt, maar geen enkel profiel past perfect bij elke omgeving. Dat is iets wat je snel leert in de praktijk. Met tailoring kun je individuele regels uitschakelen, drempelwaarden aanpassen of extra regels toevoegen — zodat je scant op wat écht relevant is voor jouw situatie:

# Genereer een tailoring-bestand op basis van een bestaand profiel
oscap xccdf generate fix \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  --fix-type bash \
  /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml > /dev/null

# Of maak een tailoring-bestand met SCAP Workbench (grafisch):
# 1. Laad het SSG-bestand
# 2. Selecteer een profiel
# 3. Schakel regels in/uit die niet van toepassing zijn
# 4. Sla op als tailoring-bestand (XML)

# Gebruik het tailoring-bestand bij een scan
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
  --tailoring-file /etc/openscap/mijn-tailoring.xml \
  --results /var/log/compliance/openscap/tailored-results.xml \
  --report /var/log/compliance/openscap/tailored-rapport.html \
  /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml

Ubuntu Security Guide (USG): CIS-compliance vereenvoudigd

Voor Ubuntu-gebruikers biedt Canonical een extra tool: de Ubuntu Security Guide (USG). Het is een gestroomlijnde wrapper rond OpenSCAP, specifiek ontworpen voor Ubuntu en de CIS Benchmarks. Minder flexibel dan raw OpenSCAP, maar voor veel use cases gewoon prima:

# USG is beschikbaar via Ubuntu Pro (gratis voor maximaal 5 machines)
sudo pro enable usg

# Audit je systeem tegen CIS Level 1 Server
sudo usg audit cis_level1_server

# Bekijk het resultaat — USG toont een overzichtelijke samenvatting
# met pass/fail per regel en een totaalpercentage

# Fix alle gefaalde regels automatisch
sudo usg fix cis_level1_server

# Na de fix: herstart en audit opnieuw om het resultaat te verifiëren
sudo reboot
sudo usg audit cis_level1_server

Het voordeel van USG ten opzichte van raw OpenSCAP is de eenvoud: je hoeft geen lange oscap-commando's met profiel-ID's en bestandspaden te onthouden. Het nadeel is duidelijk: het werkt alleen op Ubuntu en ondersteunt alleen CIS-profielen. Voor RHEL of STIG-compliance moet je toch terug naar OpenSCAP zelf.

Compliance integreren in je CI/CD-pipeline

De ultieme stap is het integreren van compliance-scans in je deployment-pipeline. Hiermee voorkom je dat servers die niet aan je beveiligingsstandaarden voldoen ooit in productie komen — en dat is precies hoe het hoort te werken. Shift left, ook voor security:

# Voorbeeld: GitLab CI/CD-stage voor compliance-scanning
# .gitlab-ci.yml

compliance_scan:
  stage: security
  image: registry.access.redhat.com/ubi9/ubi
  before_script:
    - dnf install -y openscap-scanner scap-security-guide
  script:
    - |
      oscap xccdf eval \
        --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
        --results results.xml \
        --report rapport.html \
        /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml || true

      # Controleer het aantal gefaalde regels
      FAILS=$(grep -c 'result="fail"' results.xml || echo "0")
      echo "Aantal gefaalde regels: $FAILS"

      # Faal de pipeline als er meer dan 5 kritieke failures zijn
      if [ "$FAILS" -gt 5 ]; then
        echo "Te veel compliance-failures. Pipeline geblokkeerd."
        exit 1
      fi
  artifacts:
    paths:
      - rapport.html
      - results.xml
    expire_in: 30 days
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
# Voorbeeld: GitHub Actions workflow
# .github/workflows/compliance.yml

name: Compliance Scan
on:
  pull_request:
    branches: [main]

jobs:
  openscap-scan:
    runs-on: ubuntu-latest
    steps:
      - name: Installeer OpenSCAP
        run: |
          sudo apt update
          sudo apt install -y openscap-scanner ssg-base ssg-ubuntu

      - name: Voer CIS-scan uit
        run: |
          sudo oscap xccdf eval \
            --profile xccdf_org.ssgproject.content_profile_cis_level1_server \
            --results results.xml \
            --report rapport.html \
            /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml || true

      - name: Upload rapport
        uses: actions/upload-artifact@v4
        with:
          name: compliance-rapport
          path: rapport.html

Veelgemaakte fouten bij compliance-scanning

Na het opzetten van compliance-scanning bij tientallen organisaties zie ik steeds dezelfde fouten terugkomen. Sommige keer op keer. Dus voor de duidelijkheid:

  • Lynis als gewone gebruiker draaien — Hierdoor worden veel geprivilegieerde tests overgeslagen en krijg je een onbetrouwbaar lage score. Draai Lynis altijd met sudo. Altijd.
  • Automatische remediatie zonder testen — OpenSCAP's --remediate vlag kan services verstoren. Test altijd eerst op een staging-omgeving voordat je dit in productie toepast.
  • 100% compliance nastreven — Niet elke regel is relevant voor elke omgeving. Gebruik tailoring om irrelevante regels uit te schakelen in plaats van je systeem onnodig complex te maken. Een score van 95% met een doordacht tailoring-bestand is beter dan een geforceerde 100% die je omgeving instabiel maakt.
  • Eenmalig scannen — Compliance is geen momentopname. Configuratiedrift treedt continu op. Automatiseer je scans en monitor de trend over tijd.
  • Rapporten genereren zonder actie — Dit is misschien wel de meest gemaakte fout. Een rapport dat in een la verdwijnt heeft nul waarde. Koppel je compliance-rapporten aan een concreet remediatieproces met eigenaren en deadlines.

Veelgestelde vragen

Wat is het verschil tussen Lynis en OpenSCAP?

Lynis is een brede, pragmatische beveiligingsaudit-tool die meer dan 300 checks uitvoert op basis van best practices en een hardening index score geeft. OpenSCAP is een formele compliance-scanner die je systeem toetst aan specifieke standaarden zoals CIS Benchmarks, DISA STIG en PCI DSS, met machine-leesbare resultaten en automatische remediatiemogelijkheden. Kort gezegd: gebruik Lynis voor snelle dagelijkse checks en OpenSCAP voor formele compliance-rapportage.

Hoe vaak moet ik een beveiligingsaudit uitvoeren op mijn Linux-servers?

Voor productieservers raad ik aan om Lynis dagelijks of wekelijks als geautomatiseerde cron-job te draaien en OpenSCAP-scans minimaal maandelijks uit te voeren. Voer daarnaast altijd een extra scan uit na grote configuratiewijzigingen, package-updates of het deployen van nieuwe services. De CIS Benchmarks adviseren continue monitoring als onderdeel van je beveiligingsbeleid — en daar ben ik het volledig mee eens.

Kan ik OpenSCAP-remediatie veilig toepassen op productieservers?

Automatische remediatie met OpenSCAP is krachtig maar vereist voorzichtigheid. Pas het altijd eerst toe op een staging- of testomgeving. Genereer bij voorkeur eerst een Bash-script of Ansible Playbook met oscap xccdf generate fix, review dit handmatig en pas het dan gecontroleerd toe. Sommige wijzigingen kunnen services verstoren of herstarts vereisen die je liever plant dan dat ze je verrassen.

Welke CIS Benchmark-level moet ik kiezen: Level 1 of Level 2?

CIS Level 1 is ontworpen als een praktisch beveiligingsbasislijn die op de meeste systemen kan worden toegepast zonder significante prestatie-impact of functionaliteitsverlies. Level 2 voegt strengere maatregelen toe voor omgevingen met hogere beveiligingseisen, maar kan de bruikbaarheid of prestaties beïnvloeden. Begin met Level 1 en evalueer dan of Level 2 echt noodzakelijk is voor jouw specifieke compliance-eisen. Niet elk systeem heeft dat nodig.

Hoe integreer ik compliance-scanning met Wazuh of een SIEM-oplossing?

Wazuh heeft ingebouwde ondersteuning voor zowel OpenSCAP als Lynis. Voor OpenSCAP kun je de Wazuh-agent configureren om periodiek oscap-scans uit te voeren en de XML-resultaten naar de Wazuh-manager te sturen. Voor Lynis kun je de JSON-output doorsturen naar je SIEM. Beide tools produceren gestructureerde output die gemakkelijk te parseren is voor alerting en dashboarding — iets wat ik in de praktijk goed heb zien werken bij teams die hun compliance-data willen koppelen aan hun bestaande monitoring-stack.

Over de Auteur Editorial Team

Our team of expert writers and editors.