Automatizovaný audit bezpečnosti Linuxu pomocou OpenSCAP: Sprievodca CIS benchmarkami a remediáciou

Úvod: Prečo je automatizovaný audit bezpečnosti v roku 2026 nevyhnutný

Bezpečnostná krajina Linuxu sa za posledné dva roky dramaticky zmenila. V roku 2024 bolo v jadre Linuxu objavených a zdokumentovaných 3 529 CVE zraniteľností — číslo, ktoré mnohých administrátorov poriadne prekvapilo. No rok 2025 túto štatistiku ešte prekonal: do konca roka bolo evidovaných viac ako 5 530 CVE zraniteľností v jadre Linuxu, čo predstavuje nárast o viac než 56 %. Úprimne, to je dosť znepokojivé číslo.

Agentúra CISA len za prvých desať mesiacov roku 2025 pridala do svojho katalógu Known Exploited Vulnerabilities sedem aktívne zneužívaných zraniteľností jadra. Ransomvérové skupiny ako Qilin a RansomHub tieto chyby využili na útoky voči stovkám organizácií v 62 krajinách.

V takomto prostredí už manuálne kontroly bezpečnosti jednoducho nestačia. Administrátor spravujúci desiatky alebo stovky serverov nemôže ručne overovať tisíce konfiguračných nastavení na každom jednom stroji. Práve tu nastupuje automatizovaný audit bezpečnosti — systematický, opakovateľný a merateľný prístup k overovaniu súladu systémov s bezpečnostnými štandardmi.

Tak poďme na to. Tento sprievodca vás prevedie kompletným procesom automatizovaného auditu Linuxu pomocou nástroja OpenSCAP a benchmarkov CIS (Center for Internet Security). Od inštalácie cez praktické skenovanie až po automatizovanú remediáciu a integráciu do CI/CD potrubí — naučíte sa všetko, čo potrebujete na zabezpečenie vašej infraštruktúry.

Čo je SCAP a OpenSCAP

Protokol SCAP

SCAP (Security Content Automation Protocol) je súbor špecifikácií vytvorených organizáciou NIST (National Institute of Standards and Technology). Definujú štandardizovaný spôsob vyjadrenia a manipulácie s bezpečnostnými údajmi. SCAP zahŕňa niekoľko kľúčových komponentov:

• XCCDF (Extensible Configuration Checklist Description Format) — jazyk na definovanie bezpečnostných kontrolných zoznamov a benchmarkov
• OVAL (Open Vulnerability and Assessment Language) — jazyk na opis zraniteľností a konfigurácií systémov
• CPE (Common Platform Enumeration) — štandardizované pomenovanie platforiem a softvéru
• CVE (Common Vulnerabilities and Exposures) — identifikátory pre známe zraniteľnosti
• CVSS (Common Vulnerability Scoring System) — systém hodnotenia závažnosti zraniteľností
• CCE (Common Configuration Enumeration) — identifikátory pre konfiguračné nastavenia

Tieto komponenty spoločne vytvárajú ekosystém, v ktorom je možné bezpečnostné politiky formálne popísať, automaticky vyhodnotiť a výsledky štandardizovane zdokumentovať. Je to v podstate spoločný jazyk, ktorým sa bezpečnostné nástroje medzi sebou dorozumievajú.

OpenSCAP — open-source implementácia

OpenSCAP je open-source implementácia protokolu SCAP, vyvíjaná primárne spoločnosťou Red Hat. Skladá sa z niekoľkých nástrojov:

• oscap — hlavný príkazový riadok na skenovanie a vyhodnocovanie
• oscap-ssh — nástroj na vzdialené skenovanie cez SSH
• SCAP Workbench — grafické rozhranie na prehliadanie a prispôsobovanie profilov
• OpenSCAP Daemon — služba na plánovanie pravidelných skenov
• libopenscap — C knižnica, na ktorej sú postavené všetky nástroje

OpenSCAP dokáže spracovať obsah vo formátoch XCCDF, OVAL, DataStream a ARF (Asset Reporting Format). Čo je na tom skvelé — môžete používať bezpečnostný obsah od rôznych poskytovateľov (CIS, DISA STIG, PCI DSS) a všetko spravovať v jednom nástroji.

CIS Benchmarky: Štruktúra a úrovne

Čo sú CIS Benchmarky

CIS Benchmarky sú konsenzuálne bezpečnostné konfiguračné odporúčania, vytvorené komunitou bezpečnostných expertov pod záštitou organizácie Center for Internet Security. Pre Linuxové distribúcie existujú špecializované benchmarky — CIS Benchmark pre RHEL 9, pre Ubuntu 24.04 LTS, pre SUSE Linux Enterprise 15 a ďalšie.

Každý benchmark obsahuje stovky konkrétnych odporúčaní rozdelených do logických kategórií.

Úroveň 1 vs. Úroveň 2

CIS Benchmarky definujú dve úrovne prísnosti:

• Úroveň 1 (Level 1) — základné bezpečnostné odporúčania, ktoré by mali byť aplikované na každom systéme. Tieto nastavenia majú minimálny dopad na funkčnosť a výkon. Príklady: zabezpečenie správnych oprávnení na konfiguračné súbory, zakázanie nepotrebných služieb, konfigurácia základného auditovania.
• Úroveň 2 (Level 2) — rozšírené odporúčania pre prostredia s vyššími bezpečnostnými požiadavkami. Tu už treba rátať s merateľným dopadom na výkon alebo funkčnosť. Príklady: šifrovanie dátových partícií, striktné auditovanie systémových volaní, pokročilá konfigurácia SELinux/AppArmor.

Štruktúra benchmarku

Typický CIS Benchmark pre Linux je rozdelený do týchto sekcií:

1. Počiatočné nastavenie — konfigurácia súborových systémov, aktualizácie softvéru, zabezpečenie zavádzača
2. Služby — zakázanie nepotrebných služieb (xinetd, avahi, CUPS, DHCP, LDAP, NFS, DNS, FTP, HTTP, IMAP, Samba, Squid, SNMP)
3. Konfigurácia siete — sieťové parametre jadra, firewall, bezdrôtové rozhrania
4. Auditovanie a protokolovanie — konfigurácia auditd, rsyslog/journald, rotácia logov
5. Prístup, autentifikácia a autorizácia — konfigurácia crond, SSH, PAM, heslové politiky
6. Správa systému — oprávnenia súborov, používateľské nastavenia, ovládanie SUID/SGID

Každé odporúčanie obsahuje popis, zdôvodnenie, postup na audit (overenie) a postup na remediáciu (nápravu). Práve táto štruktúrovanosť je to, čo umožňuje automatizáciu pomocou nástrojov ako OpenSCAP.

Inštalácia OpenSCAP na rôznych distribúciách

Red Hat Enterprise Linux / CentOS Stream / Rocky Linux / AlmaLinux

Na distribúciách založených na RHEL je inštalácia najjednoduchšia, pretože OpenSCAP je plne integrovaný do ekosystému Red Hat:

# Inštalácia OpenSCAP nástrojov a bezpečnostného obsahu
sudo dnf install -y openscap-scanner scap-security-guide openscap-utils

# Overenie inštalácie
oscap --version

# Bezpečnostný obsah sa nachádza v:
ls /usr/share/xml/scap/ssg/content/
# ssg-rhel9-ds.xml  ssg-rhel9-xccdf.xml  ssg-rhel9-oval.xml ...

Balík scap-security-guide (SSG) obsahuje predpripravené SCAP profily vrátane CIS benchmarkov, DISA STIG profilov a ďalších. Pre RHEL 9 je to jeden z najkompletnejších zdrojov bezpečnostného obsahu.

Ubuntu / Debian

Na Ubuntu a Debian distribúciách je inštalácia len o trochu zložitejšia:

# Inštalácia OpenSCAP
sudo apt update
sudo apt install -y libopenscap8 openscap-scanner openscap-utils

# Inštalácia SCAP Security Guide
sudo apt install -y ssg-debian ssg-ubuntu

# Alternatívne — stiahnutie najnovšieho obsahu z ComplianceAsCode
wget https://github.com/ComplianceAsCode/content/releases/latest/download/scap-security-guide-0.1.75-oval-510.zip
unzip scap-security-guide-0.1.75-oval-510.zip -d /opt/ssg/

# Overenie inštalácie
oscap --version

# Obsah pre Ubuntu 24.04
ls /usr/share/xml/scap/ssg/content/ssg-ubuntu2404-ds.xml

SUSE Linux Enterprise / openSUSE

# Inštalácia na SUSE Linux Enterprise
sudo zypper install -y openscap-utils openscap-scanner scap-security-guide

# Na openSUSE Tumbleweed/Leap
sudo zypper install -y openscap openscap-utils scap-security-guide

# Overenie
oscap --version

# Obsah pre SLES 15
ls /usr/share/xml/scap/ssg/content/ssg-sle15-ds.xml

Overenie funkčnosti inštalácie

Po inštalácii na akejkoľvek distribúcii si overte, že nástroj dokáže načítať bezpečnostný obsah:

# Zobrazenie informácií o DataStream súbore
oscap info /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Výstup by mal obsahovať zoznam profilov, referenčných dokumentov
# a podporovaných platforiem

Praktické skenovanie s oscap príkazmi

Zistenie dostupných profilov

Prvý krok pred skenovaním — zistite, aké profily máte k dispozícii pre váš systém:

# Výpis všetkých dostupných profilov v DataStream súbore
oscap info --profiles /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Typický výstup:
# xccdf_org.ssgproject.content_profile_cis
#     CIS Red Hat Enterprise Linux 9 Benchmark for Level 2 - Server
# xccdf_org.ssgproject.content_profile_cis_server_l1
#     CIS Red Hat Enterprise Linux 9 Benchmark for Level 1 - Server
# xccdf_org.ssgproject.content_profile_cis_workstation_l1
#     CIS Red Hat Enterprise Linux 9 Benchmark for Level 1 - Workstation
# xccdf_org.ssgproject.content_profile_cis_workstation_l2
#     CIS Red Hat Enterprise Linux 9 Benchmark for Level 2 - Workstation
# xccdf_org.ssgproject.content_profile_stig
#     DISA STIG for Red Hat Enterprise Linux 9
# xccdf_org.ssgproject.content_profile_pci-dss
#     PCI-DSS v4.0 Control Baseline for RHEL 9

Spustenie základného skenu

Teraz prichádza tá zaujímavá časť — spustíme prvý bezpečnostný sken voči CIS Level 1 Server profilu:

# Základný sken s CIS Level 1 profilom a generovaním HTML správy
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --results /tmp/cis-l1-results.xml \
  --report /tmp/cis-l1-report.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Sken s CIS Level 2 profilom
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis \
  --results /tmp/cis-l2-results.xml \
  --report /tmp/cis-l2-report.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

Príkaz oscap xccdf eval vyhodnotí systém voči zvolenému profilu. Parameter --results uloží strojovo čitateľné výsledky vo formáte XML a parameter --report vygeneruje prehľadnú HTML správu. Tú si potom jednoducho otvoríte v prehliadači.

Generovanie rôznych formátov výstupov

# Generovanie ARF (Asset Reporting Format) správy
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --results-arf /tmp/cis-l1-arf.xml \
  --report /tmp/cis-l1-report.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Konverzia výsledkov na HTML správu dodatočne
oscap xccdf generate report /tmp/cis-l1-results.xml > /tmp/cis-l1-report-v2.html

# Generovanie správy vo formáte pre SCAP Workbench
oscap xccdf generate custom \
  --stylesheet /usr/share/openscap/xsl/xccdf-report.xsl \
  /tmp/cis-l1-results.xml > /tmp/custom-report.html

Skenovanie s podrobným výstupom

Ak chcete vidieť, čo sa deje „pod kapotou" počas skenovania:

# Verbose výstup na konzolu počas skenovania
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --results /tmp/cis-l1-results.xml \
  --report /tmp/cis-l1-report.html \
  --verbose DEVEL \
  --progress \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml 2>&1 | tee /tmp/scan-log.txt

Porozumenie výsledkom skenu a HTML správam

Návratové kódy oscap

Príkaz oscap vracia rôzne návratové kódy, ktoré sú kľúčové pre automatizáciu:

• 0 — všetky pravidlá prešli úspešne (pass)
• 1 — interná chyba v oscap
• 2 — aspoň jedno pravidlo zlyhalo (fail) — a toto je najčastejší výsledok pri prvom skene, takže sa nenechajte odradiť

Štruktúra HTML správy

Vygenerovaná HTML správa obsahuje niekoľko dôležitých sekcií:

• Súhrnné skóre — percentuálne vyjadrenie súladu (napríklad 67 % pravidiel prešlo)
• Zoznam pravidiel — každé pravidlo s výsledkom pass, fail, notapplicable alebo error
• Detaily zlyhania — pre každé zlyhané pravidlo presný popis, čo bolo očakávané a čo bolo nájdené
• Odkazy na CCE — prepojenia na identifikátory Common Configuration Enumeration
• Odporúčania na nápravu — textový popis krokov na remediáciu

Analýza výsledkov z príkazového riadku

# Zobrazenie počtu úspešných a neúspešných pravidiel
oscap xccdf generate stats /tmp/cis-l1-results.xml

# Filtrovanie len zlyhavších pravidiel
oscap xccdf generate report \
  --result-id xccdf_org.open-scap_testresult_xccdf_org.ssgproject.content_profile_cis_server_l1 \
  /tmp/cis-l1-results.xml | grep -c "fail"

# Export zlyhavších pravidiel do textového súboru
xmlstarlet sel -t -m "//rule-result[result='fail']" \
  -v "@idref" -n /tmp/cis-l1-results.xml > /tmp/failed-rules.txt

Automatizovaná remediácia

Online remediácia

OpenSCAP podporuje priamu (online) remediáciu — automatické opravenie nálezov priamo počas skenovania. Upozornenie: tento prístup by ste mali vždy najprv otestovať v neprodukčnom prostredí. Automatické zmeny konfigurácie totiž môžu (a radi to robia) ovplyvniť funkčnosť služieb.

# Online remediácia — sken a okamžitá oprava nálezov
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --remediate \
  --results /tmp/cis-l1-remediated-results.xml \
  --report /tmp/cis-l1-remediated-report.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Po remediácii spustite opätovný sken na overenie
sudo oscap xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --results /tmp/cis-l1-post-remediation.xml \
  --report /tmp/cis-l1-post-remediation.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

Generovanie Bash remediačného skriptu

Bezpečnejší prístup (a ten, ktorý osobne odporúčam) je vygenerovať remediačný skript, preskúmať ho a až potom spustiť:

# Generovanie bash skriptu na remediáciu
oscap xccdf generate fix \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --fix-type bash \
  --output /tmp/cis-l1-remediation.sh \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Generovanie skriptu len pre zlyhavšie pravidlá z predchádzajúceho skenu
oscap xccdf generate fix \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --fix-type bash \
  --result-id "" \
  --output /tmp/cis-l1-fix-failures.sh \
  /tmp/cis-l1-results.xml

# Preskúmanie a spustenie skriptu
less /tmp/cis-l1-remediation.sh
sudo bash /tmp/cis-l1-remediation.sh

Generovanie Ansible playbooku

Pre prostredia, kde sa používa Ansible (a to je v roku 2026 asi väčšina z nás), je možné vygenerovať kompletný playbook:

# Generovanie Ansible playbooku
oscap xccdf generate fix \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --fix-type ansible \
  --output /tmp/cis-l1-playbook.yml \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Generovanie playbooku len pre nálezy z existujúcich výsledkov
oscap xccdf generate fix \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --fix-type ansible \
  --result-id "" \
  --output /tmp/cis-l1-fix-playbook.yml \
  /tmp/cis-l1-results.xml

# Spustenie vygenerovaného playbooku
ansible-playbook -i inventory.ini -b /tmp/cis-l1-playbook.yml

Prispôsobenie profilov — Tailoring

Prečo je prispôsobenie nevyhnutné

Žiadny predpripravený bezpečnostný profil nie je perfektný pre každé prostredie. A to je úplne v poriadku. Niektoré pravidlá môžu byť neaplikovateľné (napríklad pravidlá pre bezdrôtové rozhrania na serveroch v dátovom centre — to nedáva zmysel), iné môžu byť príliš prísne pre vaše konkrétne nasadenie.

CIS Benchmarky samy o sebe odporúčajú, aby organizácie profily prispôsobili svojmu kontextu.

Vytvorenie tailoring súboru

Tailoring súbor je XML dokument, ktorý modifikuje existujúci profil — zapína alebo vypína konkrétne pravidlá a mení hodnoty parametrov:

<?xml version="1.0" encoding="UTF-8"?>
<xccdf-1.2:Tailoring xmlns:xccdf-1.2="http://checklists.nist.gov/xccdf/1.2"
  id="xccdf_custom_tailoring_cis_l1_modified">
  <xccdf-1.2:benchmark href="/usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml"/>
  <xccdf-1.2:version time="2026-02-06T00:00:00">1.0</xccdf-1.2:version>
  <xccdf-1.2:Profile id="xccdf_custom_profile_cis_l1_tailored"
    extends="xccdf_org.ssgproject.content_profile_cis_server_l1">
    <xccdf-1.2:title>CIS L1 Server - Prispôsobený profil</xccdf-1.2:title>
    <xccdf-1.2:description>
      CIS Level 1 Server profil prispôsobený pre naše produkčné prostredie
    </xccdf-1.2:description>

    <!-- Vypnutie pravidla pre bezdrôtové rozhrania (nie sú na serveroch) -->
    <xccdf-1.2:select idref="xccdf_org.ssgproject.content_rule_wireless_disable_interfaces"
      selected="false"/>

    <!-- Úprava minimálnej dĺžky hesla na 16 znakov -->
    <xccdf-1.2:set-value
      idref="xccdf_org.ssgproject.content_value_var_password_pam_minlen">16</xccdf-1.2:set-value>

    <!-- Úprava maximálneho veku hesla na 60 dní -->
    <xccdf-1.2:set-value
      idref="xccdf_org.ssgproject.content_value_var_accounts_maximum_age_login_defs">60</xccdf-1.2:set-value>

    <!-- Pridanie dodatočného pravidla z Level 2 -->
    <xccdf-1.2:select idref="xccdf_org.ssgproject.content_rule_audit_rules_kernel_module_loading"
      selected="true"/>
  </xccdf-1.2:Profile>
</xccdf-1.2:Tailoring>

Použitie tailoring súboru pri skenovaní

# Sken s prispôsobeným profilom
sudo oscap xccdf eval \
  --profile xccdf_custom_profile_cis_l1_tailored \
  --tailoring-file /opt/security/cis-l1-tailoring.xml \
  --results /tmp/cis-l1-tailored-results.xml \
  --report /tmp/cis-l1-tailored-report.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

SCAP Workbench pre grafické prispôsobenie

Ak uprednostňujete grafické rozhranie (a kto by vás za to súdil), SCAP Workbench umožňuje interaktívne prispôsobenie profilov. Môžete vizuálne zapínať a vypínať pravidlá, meniť hodnoty parametrov a exportovať výsledný tailoring súbor:

# Inštalácia SCAP Workbench
sudo dnf install -y scap-workbench    # RHEL/Fedora
sudo apt install -y scap-workbench    # Ubuntu/Debian

# Spustenie
scap-workbench &

Integrácia s Ansible pre celopodnikovú správu súladu

Ansible rola pre OpenSCAP skenovanie

Pre správu súladu naprieč celou flotilou serverov je Ansible ideálnym nástrojom. Nasledujúci playbook nainštaluje OpenSCAP, spustí sken a zhromaždí výsledky na centrálnom serveri:

---
# compliance-scan.yml — Ansible playbook pre celopodnikový CIS audit
- name: Audit súladu s CIS benchmarkami
  hosts: all
  become: true
  vars:
    scap_profile: xccdf_org.ssgproject.content_profile_cis_server_l1
    scap_content: /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml
    results_dir: /tmp/openscap-results
    central_results_dir: /opt/compliance-reports

  tasks:
    - name: Inštalácia OpenSCAP balíkov
      ansible.builtin.package:
        name:
          - openscap-scanner
          - scap-security-guide
        state: present

    - name: Vytvorenie adresára na výsledky
      ansible.builtin.file:
        path: "{{ results_dir }}"
        state: directory
        mode: '0750'

    - name: Spustenie OpenSCAP skenu
      ansible.builtin.command: >
        oscap xccdf eval
        --profile {{ scap_profile }}
        --results {{ results_dir }}/{{ inventory_hostname }}-results.xml
        --report {{ results_dir }}/{{ inventory_hostname }}-report.html
        {{ scap_content }}
      register: scan_result
      failed_when: scan_result.rc not in [0, 2]
      changed_when: false

    - name: Stiahnutie HTML správy na centrálny server
      ansible.builtin.fetch:
        src: "{{ results_dir }}/{{ inventory_hostname }}-report.html"
        dest: "{{ central_results_dir }}/{{ inventory_hostname }}-report.html"
        flat: true

    - name: Stiahnutie XML výsledkov na centrálny server
      ansible.builtin.fetch:
        src: "{{ results_dir }}/{{ inventory_hostname }}-results.xml"
        dest: "{{ central_results_dir }}/{{ inventory_hostname }}-results.xml"
        flat: true

    - name: Zobrazenie súhrnného výsledku
      ansible.builtin.debug:
        msg: >
          Sken na {{ inventory_hostname }} dokončený.
          Návratový kód: {{ scan_result.rc }}
          (0 = všetko OK, 2 = niektoré pravidlá zlyhali)

Automatizovaná remediácia cez Ansible

Tu je kompletný playbook pre remediáciu s kontrolou pred a po oprave — to je prístup, ktorý funguje naozaj dobre v praxi:

---
# compliance-remediate.yml — Sken, remediácia a overenie
- name: CIS remediácia s verifikáciou
  hosts: all
  become: true
  vars:
    scap_profile: xccdf_org.ssgproject.content_profile_cis_server_l1
    scap_content: /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml
    results_dir: /tmp/openscap-results

  tasks:
    - name: Pred-remediačný sken
      ansible.builtin.command: >
        oscap xccdf eval
        --profile {{ scap_profile }}
        --results {{ results_dir }}/pre-remediation.xml
        {{ scap_content }}
      register: pre_scan
      failed_when: pre_scan.rc not in [0, 2]
      changed_when: false

    - name: Generovanie remediačného Ansible playbooku
      ansible.builtin.command: >
        oscap xccdf generate fix
        --profile {{ scap_profile }}
        --fix-type ansible
        --result-id ""
        --output {{ results_dir }}/remediation-playbook.yml
        {{ results_dir }}/pre-remediation.xml
      delegate_to: localhost
      run_once: true

    - name: Aplikovanie remediácie
      ansible.builtin.include_tasks: "{{ results_dir }}/remediation-playbook.yml"

    - name: Po-remediačný sken
      ansible.builtin.command: >
        oscap xccdf eval
        --profile {{ scap_profile }}
        --results {{ results_dir }}/post-remediation.xml
        --report {{ results_dir }}/post-remediation-report.html
        {{ scap_content }}
      register: post_scan
      failed_when: post_scan.rc not in [0, 2]
      changed_when: false

    - name: Porovnanie výsledkov
      ansible.builtin.debug:
        msg: >
          Pred remediáciou: RC={{ pre_scan.rc }},
          Po remediácii: RC={{ post_scan.rc }}

Pravidelné skenovanie s Ansible a cron

---
# schedule-compliance-scan.yml — Nastavenie pravidelného skenovania
- name: Konfigurácia pravidelného auditovania súladu
  hosts: all
  become: true
  tasks:
    - name: Vytvorenie skenovacieho skriptu
      ansible.builtin.copy:
        dest: /opt/security/compliance-scan.sh
        mode: '0750'
        content: |
          #!/bin/bash
          TIMESTAMP=$(date +%Y%m%d_%H%M%S)
          RESULTS_DIR="/var/log/compliance"
          PROFILE="xccdf_org.ssgproject.content_profile_cis_server_l1"
          CONTENT="/usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml"

          mkdir -p "${RESULTS_DIR}"

          oscap xccdf eval \
            --profile "${PROFILE}" \
            --results "${RESULTS_DIR}/results_${TIMESTAMP}.xml" \
            --report "${RESULTS_DIR}/report_${TIMESTAMP}.html" \
            "${CONTENT}"

          EXIT_CODE=$?

          # Odoslanie notifikácie v prípade zlyhaní
          if [ ${EXIT_CODE} -eq 2 ]; then
            FAIL_COUNT=$(xmlstarlet sel -t -c \
              "count(//rule-result[result='fail'])" \
              "${RESULTS_DIR}/results_${TIMESTAMP}.xml")
            echo "Compliance sken: ${FAIL_COUNT} pravidiel zlyhalo" | \
              mail -s "Compliance Alert - $(hostname)" [email protected]
          fi

          # Rotácia starých správ (ponechanie posledných 90 dní)
          find "${RESULTS_DIR}" -name "*.xml" -mtime +90 -delete
          find "${RESULTS_DIR}" -name "*.html" -mtime +90 -delete

    - name: Nastavenie cron úlohy — týždenný sken
      ansible.builtin.cron:
        name: "Týždenný compliance sken OpenSCAP"
        minute: "0"
        hour: "2"
        weekday: "0"
        job: "/opt/security/compliance-scan.sh >> /var/log/compliance/cron.log 2>&1"

Integrácia do CI/CD potrubí pre DevSecOps

Prečo integrovať bezpečnostné skeny do CI/CD

V paradigme DevSecOps sa bezpečnosť posúva „doľava" — bližšie k vývojárskemu procesu. Integrácia OpenSCAP skenov do CI/CD potrubí znamená, že každý nový obraz operačného systému, kontajner alebo konfiguračná zmena sa automaticky overí voči bezpečnostným benchmarkom ešte predtým, než sa dostane do produkcie. A to je presne to, čo chcete.

GitLab CI/CD pipeline

# .gitlab-ci.yml — Bezpečnostný sken v CI/CD potrubí
stages:
  - build
  - security-scan
  - deploy

variables:
  SCAP_PROFILE: "xccdf_org.ssgproject.content_profile_cis_server_l1"
  SCAP_CONTENT: "/usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml"
  COMPLIANCE_THRESHOLD: 85

build-image:
  stage: build
  script:
    - docker build -t ${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA} .
    - docker push ${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHA}

openscap-scan:
  stage: security-scan
  image: registry.access.redhat.com/ubi9/ubi
  before_script:
    - dnf install -y openscap-scanner scap-security-guide xmlstarlet
  script:
    # Spustenie skenu voči CIS profilu
    - |
      oscap xccdf eval \
        --profile ${SCAP_PROFILE} \
        --results results.xml \
        --report report.html \
        ${SCAP_CONTENT} || true

    # Extrakcia skóre súladu
    - |
      PASS_COUNT=$(xmlstarlet sel -t -c "count(//rule-result[result='pass'])" results.xml)
      TOTAL_COUNT=$(xmlstarlet sel -t -c "count(//rule-result[result='pass' or result='fail'])" results.xml)
      COMPLIANCE_SCORE=$((PASS_COUNT * 100 / TOTAL_COUNT))
      echo "Skóre súladu: ${COMPLIANCE_SCORE}%"

    # Zlyhanie pipeline ak je skóre pod prahom
    - |
      if [ ${COMPLIANCE_SCORE} -lt ${COMPLIANCE_THRESHOLD} ]; then
        echo "ZLYHANIE: Skóre súladu ${COMPLIANCE_SCORE}% je pod prahom ${COMPLIANCE_THRESHOLD}%"
        exit 1
      fi
  artifacts:
    when: always
    paths:
      - report.html
      - results.xml
    expire_in: 30 days
  allow_failure: false

deploy-production:
  stage: deploy
  script:
    - echo "Nasadenie do produkcie..."
  only:
    - main
  needs:
    - openscap-scan

GitHub Actions pipeline

# .github/workflows/compliance-scan.yml
name: Bezpečnostný audit súladu

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
  schedule:
    - cron: '0 6 * * 1'  # Každý pondelok o 6:00

jobs:
  openscap-compliance:
    runs-on: ubuntu-latest
    container:
      image: registry.access.redhat.com/ubi9/ubi:latest

    steps:
      - name: Checkout kódu
        uses: actions/checkout@v4

      - name: Inštalácia OpenSCAP
        run: |
          dnf install -y openscap-scanner scap-security-guide xmlstarlet

      - name: Spustenie CIS skenu
        id: scan
        run: |
          oscap xccdf eval \
            --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
            --results results.xml \
            --report report.html \
            /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml || true

          # Výpočet skóre
          PASS=$(xmlstarlet sel -t -c "count(//rule-result[result='pass'])" results.xml)
          FAIL=$(xmlstarlet sel -t -c "count(//rule-result[result='fail'])" results.xml)
          TOTAL=$((PASS + FAIL))
          SCORE=$((PASS * 100 / TOTAL))
          echo "compliance_score=${SCORE}" >> $GITHUB_OUTPUT
          echo "failed_rules=${FAIL}" >> $GITHUB_OUTPUT

      - name: Publikovanie správy ako artefakt
        uses: actions/upload-artifact@v4
        with:
          name: compliance-report
          path: |
            report.html
            results.xml
          retention-days: 90

      - name: Overenie prahu súladu
        run: |
          SCORE=${{ steps.scan.outputs.compliance_score }}
          if [ ${SCORE} -lt 85 ]; then
            echo "::error::Skóre súladu ${SCORE}% je pod minimálnym prahom 85%"
            echo "::error::Počet zlyhavších pravidiel: ${{ steps.scan.outputs.failed_rules }}"
            exit 1
          fi
          echo "::notice::Skóre súladu: ${SCORE}% - OK"

      - name: Komentár k Pull Request
        if: github.event_name == 'pull_request'
        uses: actions/github-script@v7
        with:
          script: |
            const score = '${{ steps.scan.outputs.compliance_score }}';
            const failed = '${{ steps.scan.outputs.failed_rules }}';
            const status = score >= 85 ? '✅' : '❌';
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## ${status} Výsledok bezpečnostného auditu\n\n` +
                    `- **Skóre súladu:** ${score}%\n` +
                    `- **Zlyhavšie pravidlá:** ${failed}\n` +
                    `- **Profil:** CIS Level 1 Server\n\n` +
                    `Podrobná správa je dostupná v artefaktoch pipeline.`
            });

Skenovanie kontajnerových obrazov

OpenSCAP dokáže skenovať aj kontajnerové obrazy bez ich spustenia. To je mimoriadne užitočné v CI/CD potrubí, pretože nemusíte kontajner ani spúšťať:

# Skenovanie Docker obrazu pomocou oscap-podman
sudo oscap-podman registry.access.redhat.com/ubi9/ubi:latest xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --results /tmp/container-results.xml \
  --report /tmp/container-report.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Skenovanie zraniteľností v kontajnerovom obraze (OVAL)
sudo oscap-podman registry.access.redhat.com/ubi9/ubi:latest oval eval \
  --results /tmp/container-oval-results.xml \
  --report /tmp/container-oval-report.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-oval.xml

Vzdialené skenovanie s oscap-ssh

Základné vzdialené skenovanie

Nástroj oscap-ssh umožňuje skenovať vzdialené systémy bez nutnosti inštalovať bezpečnostný obsah na cieľovom stroji. Stačí, aby na cieľovom systéme bol nainštalovaný balík openscap-scanner:

# Základné vzdialené skenovanie
oscap-ssh [email protected] 22 xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --results /tmp/remote-results.xml \
  --report /tmp/remote-report.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

# Vzdialené skenovanie s konkrétnym SSH kľúčom
oscap-ssh --ssh-key ~/.ssh/audit_key [email protected] 22 xccdf eval \
  --profile xccdf_org.ssgproject.content_profile_cis_server_l1 \
  --results /tmp/remote-results.xml \
  --report /tmp/remote-report.html \
  /usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml

Hromadné vzdialené skenovanie

Pre skenovanie viacerých serverov naraz si vytvorte jednoduchý skript. V praxi to vyzerá asi takto:

#!/bin/bash
# bulk-remote-scan.sh — Hromadné vzdialené skenovanie

SERVERS="
web01.firma.sk
web02.firma.sk
db01.firma.sk
db02.firma.sk
app01.firma.sk
app02.firma.sk
"

PROFILE="xccdf_org.ssgproject.content_profile_cis_server_l1"
CONTENT="/usr/share/xml/scap/ssg/content/ssg-rhel9-ds.xml"
RESULTS_DIR="/opt/compliance-reports/$(date +%Y%m%d)"
SSH_USER="audit"
SSH_KEY="~/.ssh/audit_key"

mkdir -p "${RESULTS_DIR}"

for SERVER in ${SERVERS}; do
  echo "===== Skenovanie: ${SERVER} ====="

  oscap-ssh --ssh-key ${SSH_KEY} ${SSH_USER}@${SERVER} 22 xccdf eval \
    --profile ${PROFILE} \
    --results "${RESULTS_DIR}/${SERVER}-results.xml" \
    --report "${RESULTS_DIR}/${SERVER}-report.html" \
    ${CONTENT}

  RC=$?
  if [ ${RC} -eq 0 ]; then
    echo "[OK] ${SERVER}: Všetky pravidlá splnené"
  elif [ ${RC} -eq 2 ]; then
    FAILS=$(xmlstarlet sel -t -c "count(//rule-result[result='fail'])" \
      "${RESULTS_DIR}/${SERVER}-results.xml")
    echo "[WARN] ${SERVER}: ${FAILS} pravidiel zlyhalo"
  else
    echo "[ERROR] ${SERVER}: Chyba skenovania (RC=${RC})"
  fi

  echo ""
done

# Generovanie súhrnného prehľadu
echo "===== SÚHRN ====="
for SERVER in ${SERVERS}; do
  RESULT_FILE="${RESULTS_DIR}/${SERVER}-results.xml"
  if [ -f "${RESULT_FILE}" ]; then
    PASS=$(xmlstarlet sel -t -c "count(//rule-result[result='pass'])" "${RESULT_FILE}")
    FAIL=$(xmlstarlet sel -t -c "count(//rule-result[result='fail'])" "${RESULT_FILE}")
    TOTAL=$((PASS + FAIL))
    SCORE=$((PASS * 100 / TOTAL))
    printf "%-25s %3d%% súlad (%d/%d pravidiel)\n" "${SERVER}" "${SCORE}" "${PASS}" "${TOTAL}"
  fi
done

Pokročilé techniky a integrácie

OVAL skenovanie zraniteľností

Okrem konfiguračných benchmarkov OpenSCAP podporuje aj OVAL definície na detekciu známych zraniteľností:

# Stiahnutie OVAL definícií pre RHEL 9
wget https://access.redhat.com/security/data/oval/v2/RHEL9/rhel-9.oval.xml.bz2
bunzip2 rhel-9.oval.xml.bz2

# Skenovanie systému na zraniteľnosti
sudo oscap oval eval \
  --results /tmp/oval-results.xml \
  --report /tmp/oval-report.html \
  rhel-9.oval.xml

# Pre Ubuntu
wget https://security-metadata.canonical.com/oval/com.ubuntu.noble.usn.oval.xml.bz2
bunzip2 com.ubuntu.noble.usn.oval.xml.bz2

sudo oscap oval eval \
  --results /tmp/ubuntu-oval-results.xml \
  --report /tmp/ubuntu-oval-report.html \
  com.ubuntu.noble.usn.oval.xml

Integrácia so SIEM systémami

Pre centralizované monitorovanie súladu môžete výsledky OpenSCAP exportovať do formátov kompatibilných s SIEM systémami. Tu je ukážka konverzie do JSON:

#!/bin/bash
# export-to-siem.sh — Export výsledkov do JSON pre SIEM

RESULTS_FILE=$1
OUTPUT_FILE=$2

# Konverzia XML výsledkov na JSON pre ingesciu do Elasticsearch/Splunk
python3 <<'PYEOF'
import xml.etree.ElementTree as ET
import json
import sys
from datetime import datetime

results_file = sys.argv[1] if len(sys.argv) > 1 else "/tmp/cis-l1-results.xml"
ns = {
    'xccdf': 'http://checklists.nist.gov/xccdf/1.2',
    'oval': 'http://oval.mitre.org/XMLSchema/oval-results-5'
}

tree = ET.parse(results_file)
root = tree.getroot()

findings = []
for rule_result in root.iter('{http://checklists.nist.gov/xccdf/1.2}rule-result'):
    finding = {
        'timestamp': datetime.utcnow().isoformat(),
        'rule_id': rule_result.get('idref', ''),
        'result': rule_result.find('{http://checklists.nist.gov/xccdf/1.2}result').text,
        'severity': rule_result.get('severity', 'unknown'),
        'hostname': '$(hostname)',
        'scan_type': 'openscap_cis_benchmark'
    }
    findings.append(finding)

for f in findings:
    print(json.dumps(f))
PYEOF

Porovnanie skenov v čase

Sledovanie trendu súladu je dôležité pre preukázanie zlepšovania bezpečnosti v čase. Nasledujúci skript vám s tým pomôže:

#!/bin/bash
# compliance-trend.sh — Sledovanie trendu súladu

RESULTS_DIR="/var/log/compliance"
TREND_FILE="/var/log/compliance/trend.csv"

# Inicializácia CSV hlavičky ak neexistuje
if [ ! -f "${TREND_FILE}" ]; then
  echo "timestamp,hostname,profile,pass_count,fail_count,score_pct" > "${TREND_FILE}"
fi

# Pridanie aktuálneho výsledku
LATEST_RESULT=$(ls -t "${RESULTS_DIR}"/results_*.xml | head -1)
if [ -n "${LATEST_RESULT}" ]; then
  TIMESTAMP=$(date +%Y-%m-%dT%H:%M:%S)
  HOSTNAME=$(hostname)
  PASS=$(xmlstarlet sel -t -c "count(//rule-result[result='pass'])" "${LATEST_RESULT}")
  FAIL=$(xmlstarlet sel -t -c "count(//rule-result[result='fail'])" "${LATEST_RESULT}")
  TOTAL=$((PASS + FAIL))
  SCORE=$((PASS * 100 / TOTAL))

  echo "${TIMESTAMP},${HOSTNAME},cis_l1,${PASS},${FAIL},${SCORE}" >> "${TREND_FILE}"
  echo "Zaznamenaný výsledok: ${SCORE}% súlad (${PASS}/${TOTAL})"
fi

Osvedčené postupy a odporúčania pre rok 2026

1. Začnite s Level 1 a postupne sprísňujte

Ak s CIS benchmarkami začínate, vždy začnite s profilom Level 1. Obsahuje základné bezpečnostné opatrenia s minimálnym dopadom na funkčnosť. Až keď dosiahnete stabilný súlad nad 95 %, zvažujte prechod na Level 2.

Z vlastnej skúsenosti — snaha nasadiť hneď Level 2 na produkčné servery bez predchádzajúceho testovania sa väčšinou nevyplatí.

2. Nikdy neaplikujte remediáciu naslepo

Automatická remediácia je mocný nástroj, ale nikdy ju nespúšťajte v produkčnom prostredí bez dôkladného testovania. Vždy najprv:

• Vygenerujte remediačný skript (bash alebo Ansible)
• Preskúmajte každú zmenu, ktorú skript vykoná
• Otestujte v izolovanom prostredí (staging, dev)
• Aplikujte postupne — najprv na jednom serveri, potom na skupinách
• Po každej remediácii spustite opätovný sken na overenie

3. Prispôsobte profily vášmu prostrediu

Žiadna organizácia by nemala používať štandardné profily bez prispôsobenia. Vytvorte tailoring súbory, ktoré odrážajú vaše špecifické požiadavky, a zdokumentujte dôvody, prečo ste konkrétne pravidlá vypli alebo upravili. Toto je dôležité nielen z technického hľadiska, ale aj pre regulačné účely a audity.

4. Integrujte do existujúcich procesov

OpenSCAP skeny by nemali byť izolovanou aktivitou. Integrujte ich do:

• CI/CD potrubí — každý nový obraz sa skenuje pred nasadením
• Konfiguračného manažmentu — Ansible, Puppet alebo Chef vykonávajú pravidelnú remediáciu
• Monitorovacích systémov — výsledky skenov sa exportujú do SIEM/dashboardov
• Incident response procesov — pri bezpečnostnom incidente sa spustí okamžitý sken

5. Automatizujte pravidelné skenovanie

Nastavte pravidelné skeny — minimálne raz týždenne, ideálne denne. Používajte cron úlohy, Ansible Tower/AWX alebo systémy ako Jenkins. Uchovávajte historické výsledky minimálne 12 mesiacov pre sledovanie trendov a regulačné účely.

6. Riešte kompenzačné kontroly

Niektoré pravidlá CIS benchmarkov sa jednoducho nedajú aplikovať vo vašom prostredí. V takýchto prípadoch zdokumentujte kompenzačné kontroly — alternatívne opatrenia, ktoré dosahujú rovnaký bezpečnostný cieľ iným spôsobom. Napríklad, ak nemôžete zakázať USB úložné zariadenia, implementujte monitorovanie ich použitia a DLP politiky.

7. Udržiavajte obsah aktuálny

Bezpečnostný obsah (SCAP profily, OVAL definície) sa pravidelne aktualizuje. Sledujte repozitár ComplianceAsCode na GitHube a pravidelne aktualizujte balík scap-security-guide. Nové verzie často opravujú falošne pozitívne nálezy a pridávajú kontroly pre novo objavené zraniteľnosti:

# Pravidelná aktualizácia bezpečnostného obsahu
sudo dnf update -y scap-security-guide    # RHEL/Fedora
sudo apt update && sudo apt upgrade -y ssg-ubuntu  # Ubuntu

# Kontrola verzie nainštalovaného obsahu
rpm -q scap-security-guide    # RHEL
dpkg -l | grep ssg            # Ubuntu

8. Zvážte komerčné nástroje pre väčšie nasadenia

Pre organizácie s tisíckami serverov môže byť vhodné doplniť OpenSCAP o komerčné riešenia ako Red Hat Insights (integrovaný s Satellite/Capsule), Foreman alebo Nessus. Tie poskytujú centralizovaný manažment, dashboardy a pokročilý reporting. OpenSCAP ostáva výborným nástrojom na samotné skenovanie — komerčné riešenia pridávajú vrstvu orchestrácie.

9. Bezpečnosť ako kód

Ukladajte vaše tailoring súbory, remediačné playbooky, CI/CD konfigurácie a skenovacie skripty do systému správy verzií (Git). Kontrolujte zmeny cez pull requesty a vyžadujte code review od bezpečnostného tímu. Toto vytvára auditovateľnú stopu všetkých zmien bezpečnostnej konfigurácie. V roku 2026 je prístup „bezpečnosť ako kód" (Security as Code) už nie trendom, ale nevyhnutnosťou.

10. Merajte a reportujte

Pravidelne generujte prehľady o stave súladu pre vedenie organizácie. Sledujte tieto kľúčové metriky:

• Priemerné skóre súladu naprieč celou infraštruktúrou
• Trend zlepšovania (alebo zhoršovania) v čase
• Počet kritických nálezov a priemerný čas ich nápravy
• Pokrytie — percentuálny podiel systémov, ktoré sú pravidelne skenované

Tieto údaje pomáhajú nielen pri bezpečnostnom rozhodovaní, ale aj pri zdôvodňovaní investícií do bezpečnosti. A úprimne, čísla hovoria za seba lepšie než akákoľvek prezentácia.

Záver

Automatizovaný audit bezpečnosti pomocou OpenSCAP a CIS benchmarkov nie je luxusom — je to základná súčasť zodpovednej správy Linuxovej infraštruktúry. S exponenciálnym rastom zraniteľností jadra Linuxu a čoraz sofistikovanejšími útokmi ransomvérových skupín sa organizácie jednoducho nemôžu spoliehať na manuálne bezpečnostné kontroly.

OpenSCAP poskytuje kompletný, open-source a štandardizovaný nástroj na automatizáciu celého cyklu — od hodnotenia súladu cez remediáciu až po reporting. V kombinácii s Ansible a integráciou do CI/CD potrubí získavate robustný systém, ktorý dokáže:

• Odhaliť konfiguračné problémy skôr, než ich zneužijú útočníci
• Automaticky opraviť nálezy podľa overených postupov
• Preukázať súlad s regulačnými požiadavkami (PCI DSS, HIPAA, SOC 2)
• Poskytnúť viditeľnosť do bezpečnostného stavu celej infraštruktúry

Začnite ešte dnes — nainštalujte OpenSCAP, spustite prvý sken voči CIS Level 1 profilu a preskúmajte výsledky. Každý krok, aj ten najmenší, posúva vašu organizáciu k lepšej bezpečnosti. A to za to stojí.