Perché conta
Il kernel è il cuore del sistema, e molti suoi comportamenti si regolano con i parametri sysctl.
Alcuni sono rilevanti per la sicurezza: come tratta pacchetti sospetti, quanto protegge la memoria dei
processi, quanto espone ai processi non privilegiati. I default sono scelti per compatibilità, non per
massima sicurezza — e irrobustirli costa un file di configurazione. Non è il primo intervento da fare
(gli accessi e i servizi vengono prima), ma è un completamento solido.
Come si applicano
1
2
3
4
|
sysctl net.ipv4.ip_forward # leggi un parametro
sysctl -w kernel.kptr_restrict=2 # imposta a runtime (temporaneo)
# persistente: metti le righe in /etc/sysctl.d/*.conf
sysctl --system # ricarica tutti i file sysctl.d
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
# /etc/sysctl.d/99-hardening.conf
# --- Rete: anti-spoofing e pacchetti sospetti ---
net.ipv4.conf.all.rp_filter = 1 # reverse path filter: scarta pacchetti con sorgente impossibile
net.ipv4.conf.all.accept_redirects = 0 # ignora ICMP redirect (possibile MITM)
net.ipv6.conf.all.accept_redirects = 0
net.ipv4.conf.all.accept_source_route = 0 # scarta pacchetti con source routing
net.ipv4.conf.all.log_martians = 1 # logga pacchetti con indirizzi impossibili
net.ipv4.tcp_syncookies = 1 # difesa contro i SYN flood
# --- Memoria e processi ---
kernel.randomize_va_space = 2 # ASLR pieno: randomizza gli indirizzi (ostacola exploit)
kernel.kptr_restrict = 2 # nascondi gli indirizzi del kernel (/proc, dmesg)
kernel.dmesg_restrict = 1 # solo root legge il ring buffer del kernel
kernel.yama.ptrace_scope = 1 # un processo non può ispezionarne un altro a piacere
kernel.unprivileged_bpf_disabled = 1 # niente eBPF per utenti non privilegiati
kernel.kexec_load_disabled = 1 # impedisci di caricare un altro kernel a runtime
# --- Filesystem ---
fs.protected_symlinks = 1 # difesa da attacchi via link simbolici in dir condivise
fs.protected_hardlinks = 1
fs.suid_dumpable = 0 # i processi SUID non generano core dump (fuga di segreti)
|
Ciascuna chiude una porta: rp_filter e accept_redirects=0 ostacolano spoofing e MITM;
randomize_va_space=2 (ASLR) rende gli exploit di memoria molto più difficili; ptrace_scope=1
impedisce che un processo compromesso ispezioni la memoria di un altro (es. per rubare segreti);
protected_symlinks neutralizza una classe classica di attacchi nelle directory world-writable come
/tmp.
Bloccare i moduli kernel inutili
Ogni modulo kernel caricabile è codice che gira nel contesto più privilegiato. Moduli per protocolli o
filesystem esotici che non usi sono superficie d’attacco inutile: si possono mettere in blacklist.
1
2
3
4
5
|
# /etc/modprobe.d/blacklist-hardening.conf
install dccp /bin/true # protocolli di rete rari e storicamente bacati
install sctp /bin/true
install firewire-core /bin/true # interfacce DMA = rischio con accesso fisico
install usb-storage /bin/true # SOLO se non ti servono chiavette USB (es. server)
|
install <modulo> /bin/true fa sì che il tentativo di caricare il modulo non faccia nulla. Utile per
protocolli obsoleti (dccp, sctp, rds) che hanno avuto CVE e che quasi nessuno usa.
Verificare
1
2
|
sysctl -a 2>/dev/null | grep -E 'randomize_va_space|rp_filter|ptrace_scope'
lsmod # moduli attualmente caricati
|
Conclusione
Un file sysctl di hardening — anti-spoofing, ASLR pieno, restrizioni su ptrace/dmesg, protezione dei
symlink — più la blacklist dei moduli inutili, irrobustiscono il livello più profondo del sistema a
costo quasi nullo. Abbiamo coperto l’intero stack, dagli account al kernel; resta da rendere tutto
questo ripetibile e verificabile invece che manuale. È il CIS Benchmark e
l’automazione, capitolo che chiude la serie.
