CIS Benchmark: Štandard pre posilnenie kybernetickej bezpečnosti 2CIS Benchmark: Cybersecurity Hardening Standard Part 2

Posted on By Martin Hasin No Comments on CIS Benchmark: Štandard pre posilnenie kybernetickej bezpečnosti 2CIS Benchmark: Cybersecurity Hardening Standard Part 2

V digitálnej ére je kybernetická bezpečnosť kľúčovým aspektom pre organizácie všetkých veľkostí. Správna konfigurácia serverov je nevyhnutná na ochranu pred rôznymi hrozbami. Center for Internet Security (CIS) poskytuje CIS Benchmarks, čo sú osvedčené postupy na bezpečnú konfiguráciu IT systémov, vrátane Ubuntu Linux serverov.

Čo je CIS Benchmark?

CIS Benchmarks sú odporúčané bezpečnostné konfigurácie vyvinuté komunitou odborníkov na kybernetickú bezpečnosť. Tieto odporúčania pokrývajú rôzne technológie a pomáhajú organizáciám zabezpečiť ich systémy podľa najlepších praktík. Pre Ubuntu Linux sú dostupné špecifické benchmarky, ktoré poskytujú podrobný návod na bezpečnú konfiguráciu systému.

Implementácia CIS Benchmarku na Ubuntu Serveroch

Ubuntu poskytuje nástroje na automatizáciu súladu a auditu s CIS benchmarkmi. Ubuntu Security Guide (USG) je nástroj, ktorý umožňuje jednoduchú implementáciu týchto odporúčaní na Ubuntu 20.04 LTS a novších verziách. USG umožňuje:

  • Auditovať aktuálny stav systému voči CIS benchmarkom.
  • Implementovať odporúčané nastavenia na dosiahnutie súladu.
  • Prispôsobiť nastavenia podľa špecifických potrieb organizácie.

Pre staršie verzie, ako sú Ubuntu 16.04 a 18.04 LTS, sú dostupné nástroje na dosiahnutie súladu s CIS benchmarkmi.

Konfigurácia SSH podľa CIS Benchmarku

Tento Bash skript slúži na bezpečné nastavenie OpenSSH servera na Linuxe v súlade s odporúčaniami CIS Benchmarku. CIS (Center for Internet Security) poskytuje osvedčené bezpečnostné postupy na zabezpečenie serverov, vrátane bezpečnej konfigurácie SSH (Secure Shell), čo je kritický komponent vzdialeného prístupu.

Čo tento skript robí?

  1. Logovanie a záloha konfigurácie:
    • Vytvára logovací súbor /var/log/hardening_script.log.
    • Pred zmenami vykonáva zálohu súboru /etc/ssh/sshd_config (pridáva .bak na koniec).
  2. Aplikácia bezpečnostných nastavení pre SSH:
    • Zakazuje priame prihlásenie root používateľa: PermitRootLogin no
    • Obmedzuje počet pokusov o autentifikáciu: MaxAuthTries 3
    • Zakazuje prázdne heslá: PermitEmptyPasswords no
    • Zakazuje forwarding a interaktívne autentifikácie:
      • AllowAgentForwarding no
      • AllowTcpForwarding no
      • KbdInteractiveAuthentication no
    • Zakazuje X11 forwarding: X11Forwarding no
    • Obmedzuje počet paralelných session: MaxSessions 2
    • Definuje maximálny počet neúspešných spojení pred blokovaním: MaxStartups 10:30:60
    • Nastavuje šifrovacie algoritmy a MACs:
      • Odstraňuje zastarané algoritmy (napr. 3DES, MD5, SHA1)
      • Ponecháva moderné bezpečné algoritmy (napr. chacha20-poly1305)
#!/bin/bash
# Module: SSH Configuration
# Description: Configures SSH for secure operations

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"

echo "Starting SSH Configuration..."

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

# Configure SSH
SSHD_CONFIG="/etc/ssh/sshd_config"

backup_file "$SSHD_CONFIG"

cat > "$SSHD_CONFIG" <

Hardening služieb podľa CIS Benchmarku

Tento Bash skript vykonáva hardening systému odstránením nepotrebných služieb na Ubuntu/Linux serveroch. Jeho cieľom je minimalizovať možné útokové vektory tým, že zakáže a odstráni služby, ktoré nie sú nevyhnutné pre bezpečnú prevádzku servera.

CIS (Center for Internet Security) Benchmark odporúča odstránenie alebo zakázanie všetkých nepoužívaných služieb, aby sa znížilo riziko exploitácie. Skript implementuje CIS odporúčania pre minimalizáciu povrchovej plochy útoku tým, že:

  • Zakazuje nepotrebné služby (systemctl disable)
  • Zastavuje služby, ktoré bežia (systemctl stop)
  • Odstraňuje služby, ak sú nainštalované (apt-get purge -y)

Čo tento skript robí?

1️⃣ Definuje logovací mechanizmus a funkciu zálohovania konfigurácie.
2️⃣ Obsahuje funkciu na zakázanie, zastavenie a odstránenie služieb.
3️⃣ Iteruje cez zoznam potenciálne nebezpečných služieb a odstraňuje ich.
4️⃣ Zapisuje všetky akcie do logovacieho súboru /var/log/hardening_script.log.

#!/bin/bash
# Module: Service Hardening
# Description: Disables and removes unnecessary services for enhanced security

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

remove_service() {
  local service="$1"
  log "Disabling and removing service: $service"

  # Stop the service if active
  if systemctl is-active --quiet "$service"; then
    validate_change "systemctl stop \"$service\"" \
      "$service stopped successfully." \
      "Failed to stop $service."
  fi

  # Disable the service if enabled
  if systemctl is-enabled --quiet "$service"; then
    validate_change "systemctl disable \"$service\"" \
      "$service disabled successfully." \
      "Failed to disable $service."
  fi

  # Remove the service package if installed
  if dpkg -l | grep -q "^ii.*$service"; then
    validate_change "apt-get purge -y \"$service\"" \
      "$service removed successfully." \
      "Failed to remove $service."
  else
    log "$service is not installed. Skipping removal."
  fi
}

validate_change() {
  local cmd="$1"
  local success_msg="$2"
  local failure_msg="$3"

  if eval "$cmd" &>> "$LOG_FILE"; then
    log "$success_msg"
  else
    log "$failure_msg"
  fi
}

SERVICES_TO_REMOVE=(
  "autofs" "avahi-daemon" "isc-dhcp-server" "bind9" "dnsmasq" "slapd"
  "dovecot-imapd" "dovecot-pop3d" "nfs-kernel-server" "ypserv" "cups"
  "rpcbind" "rsync" "samba" "snmpd" "tftpd-hpa" "squid" "apache2"
  "nginx" "xinetd" "xserver-common" "postfix" "nis" "rsh-client"
  "talk" "telnet" "inetutils-telnet" "ldap-utils" "ftp" "tnftp" "lp"
  "bluez" "gdm3" "whoopsie" "snapd"
)

for service in "${SERVICES_TO_REMOVE[@]}"; do
  remove_service "$service"
done

log "Service hardening completed."

Hardening auditu a logovania podľa CIS Benchmarku

Tento Bash skript konfiguruje auditovací systém auditd na Linuxe v súlade s odporúčaniami CIS Benchmarku. Jeho cieľom je zabezpečiť monitorovanie kritických operácií v systéme, čím umožňuje detekciu podozrivej aktivity, neautorizovaných zmien a potenciálnych bezpečnostných incidentov.

CIS Benchmark dôrazne odporúča aktívne monitorovanie a logovanie všetkých dôležitých akcií v systéme. Tento skript implementuje CIS Level 1 a Level 2 pravidlá, ktoré:

✔ Zvyšujú viditeľnosť aktivít v systéme – detekcia podozrivých operácií.
✔ Zabraňujú neautorizovaným zmenám – sledujú dôležité konfiguračné súbory.
✔ Chrání pred eskaláciou privilégií – monitorovanie sudo, passwd, usermod.
✔ Zabezpečujú audit trail – v prípade incidentu je možné spätne analyzovať udalosti.

Čo tento skript robí?

Logovanie a záloha konfigurácie

Zapisuje všetky zmeny do logovacieho súboru /var/log/hardening_script.log Pred úpravami vytvára zálohy dôležitých súborov: /etc/audit/audit.rules (pravidlá auditu) /etc/audit/auditd.conf (konfigurácia auditd)

Inštalácia a konfigurácia auditd

Inštaluje auditovací systém auditd (apt-get install -y auditd) Aplikuje odporúčané pravidlá auditu, aby sa sledovali dôležité akcie v systéme

Monitorovanie kritických súborov a operácií

Sleduje dôležité konfiguračné súbory (/etc/passwd, /etc/shadow, /etc/ssh/sshd_config, atď.) Monitoruje prihlásenia, neúspešné pokusy o prístup, zmeny v sudoers Detekuje pokusy o úpravu sieťových nastavení, hostname, kernel parametrov Sleduje zmeny v audite samotnom (zabránime vypnutiu monitorovania)

Konfigurácia auditd.conf pre lepšie logovanie

Zvyšuje počet uchovávaných audit logov (num_logs = 10) Zväčšuje maximálnu veľkosť log súborov (max_log_file = 20MB) Zabraňuje automatickému prepisovaniu audit logov (max_log_file_action = keep_logs)

#!/bin/bash
# Module: Audit Hardening
# Description: Configures auditing and logging settings for enhanced security

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"
AUDIT_RULES_FILE="/etc/audit/audit.rules"
AUDITD_CONF="/etc/audit/auditd.conf"

echo "Starting Audit Hardening..." >> "$LOG_FILE"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

# Install and configure auditd
log "Installing auditd and setting up audit rules."
if apt-get install -y auditd &>> "$LOG_FILE"; then
  log "auditd installed successfully."
else
  log "Failed to install auditd. Check the logs for details."
  exit 1
fi

# Backup existing configuration files
backup_file "$AUDIT_RULES_FILE"
backup_file "$AUDITD_CONF"

# Configure audit rules
cat > "$AUDIT_RULES_FILE" <> "$LOG_FILE"; then
  log "auditd restarted successfully."
else
  log "Failed to restart auditd. Check the logs for details."
fi

log "Audit Hardening completed."

Hardening procesov

Tento Bash skript vykonáva hardening procesov a kernelových parametrov, čím zvyšuje bezpečnosť systému v súlade s odporúčaniami CIS Benchmarku. Cieľom je minimalizovať riziko exploitácie procesov, pamäťových zraniteľností a neoprávneného prístupu k procesom.

CIS Benchmark odporúča aplikovať bezpečnostné nastavenia procesov a kernelu, pretože: ✔ Zvyšuje ochranu pred exploitmi – ASLR a ptrace scope chránia pred útokmi na procesy.
✔ Znižuje riziko úniku citlivých dát – zakázanie core dump súborov.
✔ Odstraňuje nepotrebné služby – ktoré môžu obsahovať zraniteľnosti.
✔ Minimalizuje zbytočné procesy – čím zlepšuje výkon a stabilitu systému.

Čo tento skript robí?

Zabezpečuje logovanie a zálohu konfigurácie

  • Zapisuje všetky zmeny do log súboru /var/log/hardening_script.log
  • Pred úpravami vytvára zálohu /etc/sysctl.conf

Aplikuje bezpečnostné kernelové parametre

  • Zapína randomizáciu pamäte ASLR (kernel.randomize_va_space=2)
  • Zabraňuje procesu sledovať iné procesy (kernel.yama.ptrace_scope=2)
  • Zakazuje vytváranie core dump súborov pre SUID binárky (fs.suid_dumpable=0)

Odstraňuje nepotrebné a nebezpečné balíky

  • prelink (predvolená binárna optimalizácia, ktorá znižuje bezpečnosť)
  • apport (automatické nahlasovanie chýb môže odhaliť citlivé informácie)

Zakazuje nepotrebné služby

  • Zastavuje a zakazuje apport, aby sa predišlo úniku informácií pri crash reporte
#!/bin/bash
# Module: Process Hardening
# Description: Configures kernel parameters and removes unnecessary packages for process-level hardening

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"
SYSCTL_CONF="/etc/sysctl.conf"

echo "Starting Process Hardening..." >> "$LOG_FILE"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

apply_sysctl_param() {
  local key="$1"
  local value="$2"
  if ! grep -q "^$key" "$SYSCTL_CONF"; then
    echo "$key = $value" >> "$SYSCTL_CONF"
  else
    sed -i "s/^$key.*/$key = $value/" "$SYSCTL_CONF"
  fi
  if sysctl -w "$key=$value" &>> "$LOG_FILE"; then
    log "Applied sysctl parameter: $key = $value"
  else
    log "Failed to apply sysctl parameter: $key = $value"
  fi
}

# Backup sysctl configuration
backup_file "$SYSCTL_CONF"

# Kernel Parameters for Process Hardening
params=(
  "kernel.randomize_va_space=2"
  "kernel.yama.ptrace_scope=2"
  "fs.suid_dumpable=0"
)

for param in "${params[@]}"; do
  IFS="=" read -r key value <<< "$param"
  apply_sysctl_param "$key" "$value"
done

# Uninstall unnecessary packages
PACKAGES_TO_REMOVE=("prelink" "apport")
for package in "${PACKAGES_TO_REMOVE[@]}"; do
  if dpkg-query -s "$package" &>> "$LOG_FILE"; then
    apt-get purge -y "$package" &>> "$LOG_FILE" && log "Removed $package successfully."
  else
    log "$package is not installed, skipping removal."
  fi
done

# Disable unnecessary services
SERVICES_TO_DISABLE=("apport")
for service in "${SERVICES_TO_DISABLE[@]}"; do
  if systemctl is-active --quiet "$service"; then
    systemctl stop "$service" &>> "$LOG_FILE" && log "Stopped $service."
  fi
  if systemctl is-enabled --quiet "$service"; then
    systemctl disable "$service" &>> "$LOG_FILE" && log "Disabled $service."
  fi
done

log "Process Hardening completed."

Synchronizácia času

Tento Bash skript vykonáva hardening synchronizácie času, aby zabezpečil presné a bezpečné NTP nastavenia v súlade s odporúčaniami CIS Benchmarku. Cieľom je minimalizovať riziko časových útokov (napr. replay útokov), zabrániť neautorizovaným zmenám času a zabezpečiť presnú synchronizáciu pre auditovanie a forenznú analýzu.

CIS Benchmark odporúča zabezpečenie synchronizácie času, pretože:
✔ Presný čas je nevyhnutný pre auditovanie a forenznú analýzu.
✔ Zabraňuje útočníkom manipulovať s časovými pečiatkami (napr. pri útokoch na logy).
✔ Zabezpečuje, že všetky systémy v sieti používajú rovnaký synchronizovaný čas.
✔ Minimalizuje riziko replay útokov a neautorizovaných zmien času.

Čo tento skript robí?

Zabezpečuje logovanie a zálohu konfigurácie

  • Zapisuje všetky zmeny do log súboru /var/log/hardening_script.log.
  • Pred úpravami vytvára zálohu /etc/chrony/chrony.conf.

Inštaluje a konfiguruje Chrony ako NTP klienta

  • Inštaluje chrony, ktorý je bezpečnejší a odporúčaný oproti starším NTP riešeniam.
  • Konfiguruje ho na synchronizáciu s dôveryhodnými NTP servermi (napr. pool.ntp.org).
  • Obmedzuje prístup na NTP len pre localhost (zabraňuje neautorizovanému prístupu).
  • Povolí logovanie synchronizácie pre auditné účely.

Zakazuje systemd-timesyncd, aby sa predišlo konfliktom so chrony.

#!/bin/bash
# Module: Time Synchronization Hardening
# Description: Configures secure and accurate time synchronization settings

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"
CHRONY_CONF="/etc/chrony/chrony.conf"
TIMESYNC_SERVICE="systemd-timesyncd"

echo "Starting Time Synchronization Hardening..." >> "$LOG_FILE"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

# Install and configure chrony
log "Installing chrony for time synchronization."
if apt-get install -y chrony &>> "$LOG_FILE"; then
  log "chrony installed successfully."
else
  log "Failed to install chrony. Check the logs for details."
  exit 1
fi

# Backup chrony configuration file
backup_file "$CHRONY_CONF"

# Configure chrony with secure settings
cat > "$CHRONY_CONF" <> "$LOG_FILE"; then
  log "chrony restarted successfully."
else
  log "Failed to restart chrony. Check the logs for details."
  exit 1
fi

# Disable systemd-timesyncd if active
if systemctl is-active --quiet "$TIMESYNC_SERVICE"; then
  systemctl stop "$TIMESYNC_SERVICE" &>> "$LOG_FILE" && log "Stopped $TIMESYNC_SERVICE."
fi
if systemctl is-enabled --quiet "$TIMESYNC_SERVICE"; then
  systemctl disable "$TIMESYNC_SERVICE" &>> "$LOG_FILE" && log "Disabled $TIMESYNC_SERVICE."
fi

log "Time Synchronization Hardening completed."

Hardening jadra systému

Tento Bash skript vykonáva hardening jadra operačného systému pomocou sysctl parametrov, ktoré zabezpečujú ochranu pred sieťovými útokmi, únikom citlivých informácií a posilnenie bezpečnosti procesov. Skript je v súlade s CIS Benchmark odporúčaniami, ktoré sú štandardom pre bezpečné konfigurácie Linux systémov.

CIS Benchmark odporúča zabezpečenie jadra pomocou sysctl parametrov, aby:
✔ Zabránil únikom citlivých informácií o systéme (kernel.kptr_restrict, kernel.dmesg_restrict)
✔ Zablokoval škodlivé sieťové útoky (IP source routing, ICMP útoky, spoofing)
✔ Minimalizoval riziko buffer overflow exploitov (ASLR, fs.protected_hardlinks, fs.protected_symlinks)
✔ Zakázal IPv6, ak nie je potrebné (net.ipv6.conf.all.disable_ipv6)
✔ Zabezpečil lepšiu ochranu TCP spojení (net.ipv4.tcp_syncookies=1)

Čo tento skript robí?

Zabezpečuje logovanie a zálohovanie aktuálnej konfigurácie

  • Zmeny sa logujú do súboru /var/log/hardening_script.log.
  • Pred aplikovaním úprav sa vytvorí záloha súboru /etc/sysctl.conf.

Aplikuje bezpečnostné sysctl parametre pre ochranu jadra a sieťovej komunikácie

  • Nastavuje ochranu pamäte (ASLR, prevencia exploitov).
  • Blokuje nebezpečné sieťové protokoly a útoky (IP forwarding, source routing, ICMP).
  • Chráni pred zneužitím symbolických odkazov a tvrdých odkazov.

Aplikuje sysctl parametre dynamicky a ukladá ich do konfigurácie

  • Všetky parametre sa zapisujú do /etc/sysctl.conf a okamžite aplikujú cez sysctl -w.
#!/bin/bash
# Module: Kernel Hardening
# Description: Applies kernel-level hardening using sysctl parameters

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"
SYSCTL_CONF="/etc/sysctl.conf"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

apply_sysctl_param() {
  local key="$1"
  local value="$2"
  if ! grep -q "^$key" "$SYSCTL_CONF"; then
    echo "$key = $value" >> "$SYSCTL_CONF"
  else
    sed -i "s/^$key.*/$key = $value/" "$SYSCTL_CONF"
  fi
  if sysctl -w "$key=$value"; then
    log "Applied sysctl parameter: $key=$value"
  else
    log "Failed to apply sysctl parameter: $key=$value"
  fi
}

# Backup sysctl configuration
backup_file "$SYSCTL_CONF"

# Kernel Hardening Parameters
params=(
  "kernel.randomize_va_space=2"
  "kernel.yama.ptrace_scope=2"
  "fs.suid_dumpable=0"
  "net.ipv4.ip_forward=0"
  "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.secure_redirects=0"
  "net.ipv4.conf.default.secure_redirects=0"
  "net.ipv4.conf.all.log_martians=1"
  "net.ipv4.conf.default.log_martians=1"
  "net.ipv4.tcp_syncookies=1"
  "net.ipv6.conf.all.disable_ipv6=1"
  "net.ipv6.conf.default.disable_ipv6=1"
  "net.ipv6.conf.all.forwarding=0"
  "net.ipv6.conf.default.forwarding=0"
  "net.ipv4.icmp_echo_ignore_broadcasts=1"
  "net.ipv4.icmp_ignore_bogus_error_responses=1"
  "net.ipv4.conf.all.rp_filter=1"
  "net.ipv4.conf.default.rp_filter=1"
  "net.ipv6.conf.all.accept_ra=0"
  "net.ipv6.conf.default.accept_ra=0"
  "net.ipv4.conf.all.accept_source_route=0"
  "net.ipv4.conf.default.accept_source_route=0"
  "net.ipv6.conf.all.accept_source_route=0"
  "net.ipv6.conf.default.accept_source_route=0"
  "fs.protected_hardlinks=1"
  "fs.protected_symlinks=1"
  "kernel.kptr_restrict=2"
  "kernel.dmesg_restrict=1"
  "net.ipv4.tcp_timestamps=0"
  "net.ipv4.tcp_syncookies=1"
  "net.ipv4.conf.all.rp_filter=1"
  "net.ipv4.conf.default.rp_filter=1"
  "net.ipv4.conf.all.log_martians=1"
  "net.ipv4.conf.default.log_martians=1"
  "net.ipv4.icmp_echo_ignore_broadcasts=1"
  "net.ipv4.icmp_ignore_bogus_error_responses=1"
  "net.ipv4.conf.all.accept_source_route=0"
  "net.ipv4.conf.default.accept_source_route=0"
)

for param in "${params[@]}"; do
  IFS="=" read -r key value <<< "$param"
  apply_sysctl_param "$key" "$value"
done

log "Kernel hardening parameters applied."

echo "Kernel Hardening Completed."

Filesystem Configuration Hardening

Tento Bash skript vykonáva hardening súborového systému tým, že zakáže a zablokuje nepoužívané súborové systémy v Linuxe. Je v súlade s CIS Benchmark odporúčaniami, ktoré odporúčajú zakázať zbytočné súborové systémy, aby sa minimalizoval povrch útoku a zvýšila bezpečnosť servera.

CIS Benchmark odporúča zakázať nepoužívané súborové systémy z týchto dôvodov:

✔ Znižuje riziko exploitov a privilege escalation útokov (napr. overlayfs sa v minulosti používal na exploitovanie root práv).
✔ Minimalizuje možnosti pre škodlivý kód alebo rootkity, ktoré môžu využívať alternatívne súborové systémy.
✔ Blokuje USB storage (usb-storage), čím zabraňuje neautorizovanému prenosu dát cez USB zariadenia.
✔ Zabraňuje nahrávaniu starých a nepodporovaných súborových systémov (hfs, jffs2, cramfs).

Čo tento skript robí?

Vytvára logovací mechanizmus a zálohuje existujúce konfiguračné súbory

  • Loguje akcie do /var/log/hardening_script.log.
  • Zálohuje konfiguračné súbory pred aplikovaním zmien.

Zakazuje nepoužívané súborové systémy úpravou modprobe.d konfigurácie

  • Používa install $FS /bin/false na zakázanie ich načítania.
  • Pridáva blacklist $FS, aby sa zabránilo ich zavádzaniu.

Odstraňuje nepoužívané súborové systémy z jadra

  • Ak sú nahrané, odstráni ich pomocou modprobe -r.

Zabezpečuje, že všetky zmeny sú uložené a aplikované pri reštarte systému.

#!/bin/bash
# Module: Filesystem Configuration
# Description: Disables unnecessary filesystems for enhanced security

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"
DISABLED_FS_CONF="/etc/modprobe.d/disabled-fs.conf"
MODPROBE_CONF="/etc/modprobe.d/modprobe.conf"
FILESYSTEMS=("cramfs" "freevxfs" "hfs" "hfsplus" "overlayfs" "squashfs" "udf" "jffs2" "usb-storage")

echo "Starting Filesystem Configuration..."

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

# Ensure configuration files exist
backup_file "$DISABLED_FS_CONF"
backup_file "$MODPROBE_CONF"

touch "$DISABLED_FS_CONF"
touch "$MODPROBE_CONF"

# Disable and blacklist filesystems
for FS in "${FILESYSTEMS[@]}"; do
  echo "install $FS /bin/false" >> "$DISABLED_FS_CONF"
  echo "blacklist $FS" >> "$MODPROBE_CONF"
  log "Disabled and blacklisted filesystem: $FS"
done

# Unload filesystem modules from the kernel
for FS in "${FILESYSTEMS[@]}"; do
  if lsmod | grep -q "^$FS"; then
    if modprobe -r "$FS"; then
      log "Unloaded filesystem module: $FS"
    else
      log "Failed to unload filesystem module: $FS"
    fi
  else
    log "Filesystem module $FS is not loaded."
  fi
done

# Notify user of completion
echo "Filesystem Configuration Completed."

Audit Hardening

Tento Bash skript vykonáva hardening auditu a logovania v Linuxe pomocou auditd. Je v súlade s CIS Benchmark odporúčaniami, ktoré definujú správne konfigurácie auditd a audit.rules na zabezpečenie sledovania podstatných systémových udalostí.

CIS Benchmark odporúča aktivovať auditd a sledovať dôležité udalosti v systéme:

✔ Monitoruje úpravy systémových súborov (/etc/passwd, /etc/shadow)
✔ Sleduje príkazy vykonané s root oprávneniami
✔ Zaznamenáva sudo príkazy a prihlásenia používateľov
✔ Monitoruje kritické bezpečnostné nastavenia (sysctl, network config)
✔ Zabezpečuje ukladanie logov a bráni ich neoprávnenej zmene

Čo tento skript robí?

Logovanie a zálohovanie auditd konfigurácie

  • Loguje akcie do /var/log/hardening_script.log
  • Zálohuje auditd konfigurácie pred aplikovaním zmien

Inštalácia a konfigurácia auditd

  • Skontroluje a nainštaluje auditd, ak nie je prítomný
  • Konfiguruje audit.rules na sledovanie podstatných aktivít

Nastavenie audit pravidiel na sledovanie

  • Úprav auditu, zmien v /etc/passwd, sudo príkazov, a podozrivých aktivít
  • Zaznamenáva všetky pokusy o neoprávnený prístup k systémovým súborom
  • Sledovanie zmeny konfigurácie systému, procesov, a sieťových nastavení
#!/bin/bash
# Module: Audit Hardening
# Description: Configures auditing and logging settings for enhanced security

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"
AUDIT_RULES_FILE="/etc/audit/audit.rules"
AUDITD_CONF="/etc/audit/auditd.conf"

echo "Starting Audit Hardening..." >> "$LOG_FILE"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

# Install and configure auditd
log "Installing auditd and setting up audit rules."
if apt-get install -y auditd &>> "$LOG_FILE"; then
  log "auditd installed successfully."
else
  log "Failed to install auditd. Check the logs for details."
  exit 1
fi

# Backup existing configuration files
backup_file "$AUDIT_RULES_FILE"
backup_file "$AUDITD_CONF"

# Configure audit rules
cat > "$AUDIT_RULES_FILE" <> "$LOG_FILE"; then
  log "auditd restarted successfully."
else
  log "Failed to restart auditd. Check the logs for details."
fi

log "Audit Hardening completed."

Nastavenie AppArmor

Tento Bash skript vykonáva inštaláciu a konfiguráciu AppArmor – bezpečnostného rozšírenia pre Linux Mandatory Access Control (MAC). Je v súlade s CIS Benchmark odporúčaniami, ktoré stanovujú správne nastavenie AppArmor na ochranu systémových aplikácií.

Podľa CIS Ubuntu Server Benchmark by mal byť AppArmor aktívny a nakonfigurovaný na ochranu systémových aplikácií. Tento skript zabezpečuje:

✔ Inštaláciu AppArmor a jeho nástrojov
✔ Aktiváciu AppArmor v GRUB konfigurácii
✔ Povolenie AppArmor pri štarte systému
✔ Zmenu režimu profilov na "complain" pre bezpečné ladenie pravidiel

Dôležité: Po testovaní v režime "complain" by sa mali profily nastaviť do režimu "enforce" pre plnú ochranu.

#!/bin/bash
# Module: AppArmor Setup
# Description: Installs and configures AppArmor for Mandatory Access Control

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

validate_change() {
  local cmd="$1"
  local success_msg="$2"
  local failure_msg="$3"

  if eval "$cmd" &>> "$LOG_FILE"; then
    log "$success_msg"
  else
    log "$failure_msg"
  fi
}

install_apparmor() {
  log "Installing AppArmor and utilities..."
  validate_change "apt-get update -y && apt-get install -y apparmor apparmor-utils" \
    "AppArmor installed successfully." \
    "Failed to install AppArmor. Check log for details."
}

configure_grub_for_apparmor() {
  local grub_file="/etc/default/grub"
  backup_file "$grub_file"

  if ! grep -q "apparmor=1 security=apparmor" "$grub_file"; then
    validate_change "sed -i '/^GRUB_CMDLINE_LINUX=/ s/\"$/ apparmor=1 security=apparmor\"/' \"$grub_file\" && update-grub" \
      "AppArmor configuration added to GRUB and GRUB updated successfully." \
      "Failed to configure GRUB for AppArmor."
  else
    log "AppArmor is already configured in GRUB."
  fi
}

set_profiles_to_complain_mode() {
  log "Setting AppArmor profiles to complain mode..."
  local profiles
  profiles=$(apparmor_status | awk '/profiles are loaded/{print $1}' 2>> "$LOG_FILE")

  if [[ -z "$profiles" ]]; then
    log "No active AppArmor profiles found."
  else
    for profile in $(apparmor_status | awk '/enforce/{print $NF}' 2>> "$LOG_FILE"); do
      validate_change "aa-complain \"$profile\"" \
        "Set $profile to complain mode." \
        "Failed to set $profile to complain mode."
    done
  fi
}

# Main Execution
install_apparmor
configure_grub_for_apparmor
set_profiles_to_complain_mode

log "AppArmor setup completed."

Zabezpečenie používateľských účtov

Tento Bash skript zabezpečuje používateľské účty v Linuxe podľa CIS Benchmark odporúčaní. Cieľom je minimalizovať riziko neoprávneného prístupu, implementovať silné heslové politiky a uzamknúť neaktívne účty.

Podľa CIS Ubuntu Server Benchmark musia byť zabezpečené všetky používateľské účty:

✔ Zakázanie nepoužívaných systémových účtov
✔ Zákaz prázdnych hesiel
✔ Silná heslová politika
✔ Expirácia hesiel pre neaktívnych používateľov
✔ Použitie SHA-512 na bezpečné hashovanie hesiel

Čo tento skript robí?

1️⃣ Zálohuje dôležité konfiguračné súbory
2️⃣ Uzamyká systémové účty, ktoré nie sú potrebné
3️⃣ Zabezpečuje, aby žiadny účet nemal prázdne heslo
4️⃣ Konfiguruje politiky pre heslá v /etc/login.defs
5️⃣ Nastavuje expirácie hesiel pre neaktívne účty

#!/bin/bash
# Module: Account Security Hardening
# Description: Configures user accounts for enhanced security

LOG_FILE="/var/log/hardening_script.log"
BACKUP_SUFFIX=".bak"

echo "Starting Account Security Hardening..." >> "$LOG_FILE"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}${BACKUP_SUFFIX}" && log "Backup created for $file"
  else
    log "File $file not found, skipping backup."
  fi
}

# Lock unnecessary system accounts
log "Locking unnecessary system accounts."
for account in $(awk -F: '($3 < 1000 && $1 != "root") {print $1}' /etc/passwd); do
  usermod -L "$account" &>> "$LOG_FILE" && log "Locked account: $account."
done

# Ensure no accounts have empty passwords
log "Checking for accounts with empty passwords."
for user in $(awk -F: '($2 == "" && $3 >= 1000) {print $1}' /etc/shadow); do
  passwd -l "$user" &>> "$LOG_FILE" && log "Locked user with empty password: $user."
done

# Enforce strong password policies in /etc/login.defs
LOGIN_DEFS="/etc/login.defs"
backup_file "$LOGIN_DEFS"
sed -i 's/^PASS_MAX_DAYS.*/PASS_MAX_DAYS   90/' "$LOGIN_DEFS"
sed -i 's/^PASS_MIN_DAYS.*/PASS_MIN_DAYS   7/' "$LOGIN_DEFS"
sed -i 's/^PASS_WARN_AGE.*/PASS_WARN_AGE   14/' "$LOGIN_DEFS"
if ! grep -q "^ENCRYPT_METHOD" "$LOGIN_DEFS"; then
  echo "ENCRYPT_METHOD SHA512" >> "$LOGIN_DEFS"
else
  sed -i 's/^ENCRYPT_METHOD.*/ENCRYPT_METHOD SHA512/' "$LOGIN_DEFS"
fi
log "Updated $LOGIN_DEFS with secure password policies."

# Expire passwords for inactive accounts
log "Expiring passwords for inactive accounts."
for user in $(awk -F: '($3 >= 1000) {print $1}' /etc/passwd); do
  chage --inactive 30 "$user" &>> "$LOG_FILE" && log "Set password expiration for $user."
done

log "Account Security Hardening completed."

Hardening systémových logov

Tento Bash skript zabezpečuje systémové logovanie v Linuxe podľa CIS Benchmark odporúčaní. Cieľom je zlepšiť bezpečnosť logov, zabrať prístup nepovoleným používateľom a zabezpečiť spoľahlivé uchovávanie logov.

Podľa CIS Ubuntu Server Benchmark musí byť systémové logovanie zabezpečené:

✔ Inštalácia a konfigurácia rsyslog pre bezpečné logovanie
✔ Obmedzenie prístupu k log súborom len pre root používateľa
✔ Zálohovanie a ochrana konfiguračných súborov logovania
✔ Uloženie dôležitých logov do určených súborov pre jednoduchú kontrolu

Čo tento skript robí?

1️⃣ Zálohuje existujúce konfiguračné súbory logovania
2️⃣ Inštaluje a konfiguruje rsyslog pre bezpečné logovanie
3️⃣ Obmedzuje prístup k log súborom (zabraňuje čítaniu neautorizovanými používateľmi)

#!/bin/bash
# Module: System Log Hardening
# Description: Configures logging settings to ensure secure and reliable system logging

LOG_FILE="/var/log/hardening_script.log"
RSYSLOG_CONF="/etc/rsyslog.conf"
RSYSLOG_D_DIR="/etc/rsyslog.d"

echo "Starting System Log Hardening..." >> "$LOG_FILE"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}.bak" && log "Backup created for $file."
  else
    log "File $file not found, skipping backup."
  fi
}

# Ensure rsyslog is installed
log "Installing rsyslog if not already installed."
if apt-get install -y rsyslog &>> "$LOG_FILE"; then
  log "rsyslog installed successfully."
else
  log "Failed to install rsyslog. Check the logs for details."
  exit 1
fi

# Backup existing rsyslog configuration
backup_file "$RSYSLOG_CONF"

# Update rsyslog configuration for secure logging
cat > "$RSYSLOG_CONF" <> "$LOG_FILE"; then
  log "rsyslog restarted successfully."
else
  log "Failed to restart rsyslog. Check the logs for details."
fi

log "System Log Hardening completed."

Hardening PAM

Tento Bash skript implementuje hardening PAM (Pluggable Authentication Modules) podľa CIS Benchmark odporúčaní. Jeho cieľom je zabezpečiť silné heslá, kontrolu neúspešných prihlásení a testovať politiku overovania.

Podľa CIS Ubuntu Server Benchmark musí byť PAM nastavený tak, aby zabezpečil:

✔ Použitie silných hesiel
✔ Minimálnu dĺžku hesla a požiadavky na špeciálne znaky
✔ Zablokovanie účtov po neúspešných pokusoch o prihlásenie
✔ Automatické testovanie politiky hesiel a zamykania účtov

Čo tento skript robí?

1️⃣ Zálohuje existujúce PAM konfigurácie
2️⃣ Inštaluje knižnicu libpam-pwquality na zabezpečenie silných hesiel
3️⃣ Konfiguruje PAM, aby vyžadoval silné heslá (minimálna dĺžka, veľké/malé písmená, čísla, špeciálne znaky)
4️⃣ Testuje politiku hesiel a zamykania účtu po viacerých neúspešných pokusoch

#!/bin/bash
# Module: PAM Hardening
# Description: Configures Pluggable Authentication Modules (PAM) for enhanced security

LOG_FILE="/var/log/hardening_script.log"
PAM_COMMON_AUTH="/etc/pam.d/common-auth"
PAM_COMMON_PASSWORD="/etc/pam.d/common-password"

log() {
  echo "[$(date +%Y-%m-%dT%H:%M:%S)] $1" | tee -a "$LOG_FILE"
}

backup_file() {
  local file="$1"
  if [[ -f "$file" ]]; then
    cp "$file" "${file}.bak" && log "Backup created for $file."
  else
    log "File $file not found, skipping backup."
  fi
}

# Ensure required packages are installed
log "Installing required PAM packages."
if apt-get install -y libpam-pwquality &>> "$LOG_FILE"; then
  log "Required PAM packages installed successfully."
else
  log "Failed to install required PAM packages. Check logs for details."
  exit 1
fi

log "Starting PAM Hardening..."

# Backup PAM configuration files
backup_file "$PAM_COMMON_AUTH"
backup_file "$PAM_COMMON_PASSWORD"

# Configure PAM to enforce strong password policies
log "Configuring strong password policies in PAM."
sed -i '/pam_pwquality.so/d' "$PAM_COMMON_PASSWORD"
echo "password requisite pam_pwquality.so retry=3 minlen=12 dcredit=-1 ucredit=-1 ocredit=-1 lcredit=-1" >> "$PAM_COMMON_PASSWORD"
log "Updated $PAM_COMMON_PASSWORD to enforce strong passwords."

# # Configure lockout policy for failed login attempts
# log "Configuring lockout policy for failed logins."
# sed -i '/pam_tally2.so/d' "$PAM_COMMON_AUTH"
# echo "auth required pam_tally2.so deny=5 unlock_time=600 onerr=fail audit" >> "$PAM_COMMON_AUTH"
# log "Updated $PAM_COMMON_AUTH to lock accounts after 5 failed attempts."

# Test PAM configuration
log "Testing PAM configuration for password policies."
echo "Testing password policy: Expect rejection for weak passwords."
echo "weakpassword" | passwd --stdin testuser 2>> "$LOG_FILE"
if [[ $? -ne 0 ]]; then
  log "Password policy test passed: Weak password rejected."
else
  log "Password policy test failed: Weak password accepted."
  exit 1
fi

log "Testing lockout policy: Expect lockout after 5 failed attempts."
for i in {1..5}; do
  su -c "echo wrongpassword | su testuser" 2>> "$LOG_FILE"
done
if faillog -u testuser | grep -q "FAILURES"; then
  log "Lockout policy test passed: User locked out after repeated failures."
else
  log "Lockout policy test failed: User not locked out."
  exit 1
fi

log "PAM Hardening completed successfully."
CEO at  | martin.hasin@gmail.com | Website |  + posts

Odborník na kybernetickú bezpečnosť, správu Azure Cloud a VMware onprem. Využíva technológie, ako Checkmk a MRTG, na monitorovanie siete a zvyšovanie efektívnosti a bezpečnosti IT infraštruktúry. Kontakt: hasin(at)mhite.sk

Linux Tags:

Leave a Reply

Your email address will not be published. Required fields are marked *