Linux / kernel, sicurezza & privacy

Compilare un kernel Linux personalizzato: scheduler BORE, moduli Netfilter, privacy di rete e driver Wi-Fi con DKMS

Una guida approfondita alla personalizzazione e compilazione di un kernel Linux per workstation: dall'ottimizzazione della latenza con lo scheduler BORE all'hardening della memoria a livello ring 0, dalle contromisure contro il tracciamento di rete e l'OS fingerprinting fino alla risoluzione dei blocchi di boot e alla gestione di driver out-of-tree firmati con Machine Owner Key (MOK).

Perché compilare un kernel personalizzato oggi?

I kernel generici distribuiti dalle principali distribuzioni (Debian, Ubuntu, Arch, Fedora) sono progettati per funzionare su una gamma vastissima di hardware, dai server di calcolo ai portatili a basso consumo. Questo approccio comporta compromessi inevitabili: timer tickless conservativi, scheduler orientati al throughput grezzo piuttosto che alla reattività interattiva dei processi desktop, e una miriade di driver compilati come moduli che appesantiscono l'immagine iniziale.

Compilare un kernel specifico per la propria workstation con patchset ottimizzati (come linux-tkg) permette di ottenere vantaggi tangibili:

  • Scheduler BORE (Burst-Oriented Response Enhancer): modifica l'algoritmo di scheduling CFS/EEVDF di Linux per calcolare dinamicamente la burstiness dei thread, assegnando priorità immediata ai processi interattivi (interfaccia grafica, audio a bassa latenza, browser) senza penalizzare i job di calcolo in background.
  • Frequenza dei timer e tickless full (CONFIG_NO_HZ_FULL): riduzione drastica delle interruzioni della CPU sui core dedicati ai compiti critici.
  • Ottimizzazione nativa della microarchitettura (-march=native): istruzioni AVX2, AVX-512, BMI e AES-NI sfruttate appieno dal kernel e dai moduli di crittografia.

La trappola dei kernel "a dieta": il firewall che blocca il boot

Uno degli errori più insidiosi quando si compila un kernel personalizzato o si adottano frammenti di configurazione minimizzati (come _kernel_on_diet="true") è la perdita involontaria dei moduli di rete Netfilter (iptables e nftables).

Molti script di firewall al boot (es. in /etc/network/if-pre-up.d/ o un servizio systemd dedicato) contengono all'inizio impostazioni di sicurezza severe, come l'uscita immediata in caso di errore (set -e) e la chiusura preventiva del traffico in ingresso:

#!/bin/bash
set -e
iptables -P INPUT DROP
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -p tcp -m multiport --dports 22,80,443 -j ACCEPT
iptables -A INPUT -p icmp -m limit --limit 5/sec -j ACCEPT

Se il nuovo kernel è stato compilato senza il supporto per xt_multiport, xt_limit, nf_conntrack o nft_compat, il comando iptables fallisce non appena tenta di caricare l'estensione mancante. A causa di set -e, lo script si interrompe bruscamente dopo aver impostato INPUT DROP ma prima di aver applicato le regole di permesso (ACCEPT). Risultato: al primo riavvio la macchina perde completamente connettività di rete, impedendo qualsiasi accesso SSH remoto o navigazione locale.

Hardening difensivo dello script di firewall

Per proteggere la macchina sia da kernel difettosi sia da moduli mancanti, uno script di avvio del firewall deve essere progettato in modo difensivo:

  1. Trappola di ripristino su errore (ERR trap): in caso di fallimento imprevisto, lo script deve riaprire le policy su ACCEPT prima di uscire, consentendo l'accesso e la diagnosi anziché isolare l'host.
  2. Policy di default posticipata (Deferred DROP): mantenere INPUT ACCEPT durante tutta la sequenza di definizione delle regole e applicare la policy di DROP solo all'ultima riga, a transazione conclusa con successo.
  3. Tolleranza alle estensioni mancanti: scomporre le chiamate a moduli facoltativi (come multiport o limit) in cicli singoli con fallback.
#!/bin/bash
set -eo pipefail

IPT="/sbin/iptables-nft"
[ -x "$IPT" ] || IPT="/sbin/iptables"

# Ripristino di emergenza: se una regola fallisce, evita il lockout totale
trap '$IPT -P INPUT ACCEPT; $IPT -P FORWARD ACCEPT; echo "ERRORE: Firewall abortito, policy impostata su ACCEPT per sicurezza" >&2' ERR

# Resetta le catene mantenendo momentaneamente ACCEPT
$IPT -F
$IPT -X
$IPT -P INPUT ACCEPT
$IPT -P FORWARD ACCEPT
$IPT -P OUTPUT ACCEPT

# Loopback e traffico stabilito
$IPT -A INPUT -i lo -j ACCEPT
$IPT -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT || \
$IPT -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Servizi consentiti: fallback a porte singole se multiport fallisce
PORTS="22 80 443"
for port in $PORTS; do
    $IPT -A INPUT -p tcp --dport "$port" -j ACCEPT
done

# ICMP rate limiting con fallback
$IPT -A INPUT -p icmp -m limit --limit 5/sec -j ACCEPT || \
$IPT -A INPUT -p icmp -j ACCEPT

# Drop dei pacchetti invalidi e malformati
$IPT -A INPUT -m conntrack --ctstate INVALID -j DROP

# Policy di default applicata solo se tutte le regole precedenti sono riuscite
$IPT -P INPUT DROP
$IPT -P FORWARD DROP

echo "Firewall caricato con successo."

Hardening del Kernel a livello Ring 0: memoria e isolamento dei processi

La reattività di calcolo non deve mai compromettere la sicurezza della memoria. La compilazione del kernel offre l'opportunità unica di abilitare parametri di sicurezza a livello ring 0 che bloccano alla radice vettori di attacco locali e tentativi di privilege escalation:

  • Kernel Module Signing & Verification (CONFIG_MODULE_SIG=y, CONFIG_MODULE_SIG_ALL=y): impedisce a rootkit o malware di caricare codice arbitrario nello spazio del kernel a meno che non sia crittograficamente firmato con una chiave autorizzata (MOK o chiave interna del kernel).
  • Lockdown LSM (CONFIG_SECURITY_LOCKDOWN_LSM=y): sigilla la frontiera tra i privilegi di root (ring 3) e il kernel (ring 0). In modalità integrity o confidentiality, disabilita gli accessi diretti alla memoria fisica tramite /dev/mem, /dev/kmem, le istruzioni I/O su porte arbitrarie e l'esecuzione di kernel non verificati via kexec.
  • Restrizione di eBPF per utenti non privilegiati (kernel.unprivileged_bpf_disabled = 1): disabilita l'interprete e il compilatore JIT eBPF per account non root, chiudendo il vettore principale di attacchi a canali laterali (Spectre/Meltdown) e memory corruption.
  • Occultamento dei puntatori di memoria (kernel.kptr_restrict = 2): maschera gli indirizzi fisici del kernel in /proc/kallsyms e nelle strutture dati di rete, rendendo inefficaci le catene di Return-Oriented Programming (ROP) che tentano di bypassare KASLR.
  • Protezione contro l'ispezione della memoria tra processi (kernel.yama.ptrace_scope = 2): impedisce a qualsiasi processo (anche se eseguito con lo stesso UID) di agganciarsi tramite ptrace alla memoria di un altro processo (come browser, agenti GPG o wallet crittografici), limitando il debug ai soli processi figli precedentemente autorizzati.
  • Restrizione del buffer di diagnostica (kernel.dmesg_restrict = 1): impedisce agli utenti ordinari e ai processi confinati in container di leggere il log di dmesg, che spesso rivela dettagli architetturali dell'hardware e offset di memoria utili agli exploit.
# /etc/sysctl.d/99-kernel-hardening.conf
kernel.kptr_restrict = 2
kernel.dmesg_restrict = 1
kernel.unprivileged_bpf_disabled = 1
kernel.yama.ptrace_scope = 2
kernel.kexec_load_disabled = 1
fs.protected_fifos = 2
fs.protected_regular = 2
fs.protected_symlinks = 1
fs.protected_hardlinks = 1

Privacy di rete: anti-fingerprinting e protezione degli identificatori

A livello di stack TCP/IP, il kernel Linux standard espone una quantità allarmante di metadati che consentono a osservatori passivi e siti web di identificare, tracciare e correlare la macchina tra reti diverse:

  • Disattivazione dei TCP Timestamps (net.ipv4.tcp_timestamps = 0): per default, i pacchetti TCP includono un timestamp ad alta precisione derivato dal clock interno del kernel (jiffies). Gli analisti di rete utilizzano questo valore per calcolare l'uptime esatto del sistema, la frequenza di clock (clock skew fingerprinting) e correlare le connessioni della stessa macchina anche dietro VPN o indirizzi IP differenti. Disattivare o randomizzare i timestamp elimina questa superficie di tracciamento.
  • Estensioni di Privacy IPv6 (net.ipv6.conf.all.use_tempaddr = 2): se non configurato, l'indirizzo IPv6 globale deriva direttamente dal MAC address dell'interfaccia hardware (algoritmo EUI-64), esponendo l'identificatore univoco del dispositivo su Internet in chiaro. Impostando il valore su 2, il kernel genera automaticamente indirizzi temporanei e casuali a rotazione periodica per tutto il traffico in uscita, nascondendo l'hardware reale.
  • Prevenzione del TCP/IP Spoofing (Reverse Path Filtering): impostando rp_filter = 1, il kernel verifica che ogni pacchetto in ingresso provenga dall'interfaccia corretta rispetto alla tabella di routing, scartando all'istante pacchetti con IP sorgente contraffatto.
  • Rifiuto dei reindirizzamenti ICMP: disabilitare accept_redirects = 0 e send_redirects = 0 protegge da attacchi Man-in-the-Middle sulla rete locale che tentano di deviare il traffico alterando le rotte del gateway.
# /etc/sysctl.d/99-network-privacy.conf
net.ipv4.tcp_timestamps = 0
net.ipv4.tcp_sack = 1
net.ipv4.tcp_rfc1337 = 1
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
net.ipv4.icmp_echo_ignore_broadcasts = 1
net.ipv6.conf.all.use_tempaddr = 2
net.ipv6.conf.default.use_tempaddr = 2
net.ipv6.conf.all.accept_redirects = 0
net.ipv6.conf.default.accept_redirects = 0

Configurare i frammenti del Kernel (Kconfig e .myfrag)

Con il framework linux-tkg, le personalizzazioni possono essere dichiarate in un frammento di configurazione (es. custom.myfrag). Per garantire che l'intero stack firewall, NAT, filtraggio pacchetti e protezione della memoria sia disponibile senza conflitti, occorre abilitare sia le interfacce legacy xtables sia il sottosistema moderno nftables, insieme ai controlli di integrità:

# Netfilter Core & Connection Tracking
CONFIG_NETFILTER=y
CONFIG_NETFILTER_ADVANCED=y
CONFIG_NF_CONNTRACK=m
CONFIG_NF_CONNTRACK_MARK=y
CONFIG_NF_CONNTRACK_EVENTS=y
CONFIG_NF_NAT=m

# nftables subsystem
CONFIG_NF_TABLES=m
CONFIG_NF_TABLES_INET=y
CONFIG_NFT_CT=m
CONFIG_NFT_LIMIT=m
CONFIG_NFT_NAT=m
CONFIG_NFT_COMPAT=m

# legacy iptables / xtables modules
CONFIG_IP_NF_IPTABLES=m
CONFIG_IP_NF_FILTER=m
CONFIG_IP_NF_TARGET_REJECT=m
CONFIG_IP_NF_NAT=m
CONFIG_NETFILTER_XT_MATCH_STATE=m
CONFIG_NETFILTER_XT_MATCH_CONNTRACK=m
CONFIG_NETFILTER_XT_MATCH_MULTIPORT=m
CONFIG_NETFILTER_XT_MATCH_LIMIT=m

# Hardening della memoria e sicurezza kernel
CONFIG_SECURITY=y
CONFIG_SECURITY_LOCKDOWN_LSM=y
CONFIG_SECURITY_LOCKDOWN_LSM_EARLY=y
CONFIG_MODULE_SIG=y
CONFIG_MODULE_SIG_ALL=y
CONFIG_MODULE_SIG_SHA512=y
CONFIG_STACKPROTECTOR_STRONG=y
CONFIG_FORTIFY_SOURCE=y
CONFIG_PAGE_TABLE_ISOLATION=y
CONFIG_RANDOMIZE_BASE=y
CONFIG_RANDOMIZE_MEMORY=y

# Compressione in memoria veloce per swap e initrd
CONFIG_CRYPTO_ZSTD=y
CONFIG_ZRAM=m
CONFIG_ZSTD_COMPRESS=y
CONFIG_ZSTD_DECOMPRESS=y

Driver Wi-Fi fuori albero (out-of-tree) e DKMS: il caso Alfa AWUS1900

Gli adattatori di rete ad alta sensibilità per analisi e monitoraggio radio (come l'Alfa AWUS1900 con chipset Realtek RTL8814AU) non sono inclusi nei sorgenti ufficiali del kernel Linux. Per utilizzarli su un kernel personalizzato, è necessario compilare il modulo fuori albero (out-of-tree) e integrarlo con DKMS (Dynamic Kernel Module Support) affinché venga ricompilato automaticamente ad ogni aggiornamento del kernel.

Il file /usr/src/rtl8814au-5.8.5.1/dkms.conf definisce le regole di compilazione:

PACKAGE_NAME="rtl8814au"
PACKAGE_VERSION="5.8.5.1"
CLEAN="make clean"
MAKE="make -j$(nproc) KVER=$kernelver"
BUILT_MODULE_NAME[0]="8814au"
DEST_MODULE_LOCATION[0]="/updates/dkms"
AUTOINSTALL="YES"

Sui sistemi con Secure Boot abilitato, i moduli compilati localmente da DKMS vengono rifiutati dal kernel a meno che non siano firmati con una chiave fidata (Machine Owner Key, MOK). La firma avviene tramite kmodsign o lo script sign-file fornito con i kernel headers:

# Firma del modulo con la chiave MOK locale
sudo /usr/lib/linux-kbuild-6.13/scripts/sign-file sha256 \
    /var/lib/shim-signed/mok/MOK.priv \
    /var/lib/shim-signed/mok/MOK.der \
    /lib/modules/6.13.12-tkg-bore/updates/dkms/8814au.ko.xz

Una volta firmato e installato, il modulo può essere caricato istantaneamente con sudo modprobe 8814au e verificato via lsmod o ip link.

Privacy wireless e randomizzazione del MAC address: Durante l'uso di adattatori Wi-Fi ad alta portata, è fondamentale impedire che i probe request trasmettano il MAC address hardware reale nelle scansioni d'aria. In NetworkManager, è possibile forzare la randomizzazione continua degli identificatori sia in fase di scansione passiva sia durante le connessioni:

# /etc/NetworkManager/conf.d/00-mac-randomization.conf
[device]
wifi.scan-rand-mac-address=yes

[connection]
wifi.cloned-mac-address=random
ethernet.cloned-mac-address=random

Verifica sul campo e buone pratiche

Prima di rendere permanente un nuovo kernel personalizzato al boot:

  • Mantieni sempre un kernel di riserva funzionante: assicurati che il menu di GRUB non abbia timeout pari a zero e mantenga sempre la voce per il kernel generico della distribuzione.
  • Verifica i moduli attivi dopo il boot: controlla con lsmod | grep -E "8814au|nft_|xt_" che sia il driver wireless sia le estensioni del firewall siano regolarmente agganciati.
  • Ispeziona i log di sistema e i parametri di hardening: verifica con dmesg | grep -iE "bore|netfilter|secureboot" che lo scheduler BORE sia operativo, che i timestamp TCP siano disattivati con sysctl net.ipv4.tcp_timestamps e che KASLR sia attivo.

La combinazione di uno scheduler a bassa latenza, un frammento Netfilter completo, il confinamento della memoria ring 0, l'eliminazione dell'OS fingerprinting e una gestione strutturata dei driver out-of-tree tramite DKMS trasforma una workstation Linux in un ambiente estremamente reattivo, stabile, inviolabile e rispettoso della privacy.