Come controllare i comandi eseguiti sul server
La cronologia della shell non è un audit trail: confronta sudo, registrazione delle sessioni, hook di bash e regole auditd execve, poi invia i log fuori dal server.
Cosa registra davvero i comandi eseguiti dagli utenti sul server
Per verificare quali comandi hanno eseguito gli utenti sul server, serve un registro che l’utente non possa modificare. La cronologia della shell non è questo registro. È un file di servizio, di proprietà dell’account che lo ha scritto. Chiunque possa digitare comandi in quella shell può disabilitarlo o eliminarlo.
Esistono quattro livelli che conservano un registro effettivo, e ciascuno comporta un costo. sudo scrive una riga per ogni comando in syslog. Il logging I/O di sudo acquisisce un’intera sessione per un account. Un hook della shell, ad esempio PROMPT_COMMAND, registra ciò che digita un utente interattivo di bash. Il sottosistema di audit del kernel registra direttamente la syscall execve. Per questo è l’unico livello che osserva ogni processo. Questa guida percorre questi livelli, indica dove si ferma ciascuno e si conclude con l’aspetto che determina se tutto questo ha realmente valore: trasferire i registri fuori dalla macchina prima che la persona sottoposta ad audit possa accedervi.
Un’avvertenza prima di iniziare. Il sottosistema di audit opera nel kernel. Di conseguenza, non è possibile testarlo in un container che condivide il kernel dell’host. Esegui questi comandi su una VPS KVM il cui kernel sia sotto il tuo controllo.
Perché la cronologia della shell non è un audit trail
~/.bash_history non è una prova affidabile per quattro motivi comuni, e nessuno richiede un attaccante particolarmente esperto.
Appartiene all'utente. Il file ha modalità 600 ed è di proprietà di quell'account, quindi per rm ~/.bash_history non sono necessari privilegi. Non servono privilegi nemmeno per aprirlo in un editor e rimuovere le venti righe rilevanti.
Viene scritto quando la shell termina. Una sessione che termina con kill -9 $$ non scrive nulla, perché SIGKILL non può essere intercettato e bash non ha la possibilità di salvare la cronologia. Anche history -c prima di exit produce lo stesso effetto e fa sembrare che non sia successo nulla. Una connessione interrotta è diversa: la disconnessione invia SIGHUP alla shell interattiva e bash salva intenzionalmente la cronologia in risposta a SIGHUP e SIGTERM prima di terminare. Di conseguenza, una sessione SSH persa lascia le proprie righe nel file, a meno che la cronologia non fosse stata disattivata.
Si disattiva con una sola parola. unset HISTFILE impedisce la scrittura del file per quella sessione. set +o history interrompe immediatamente la registrazione. HISTCONTROL=ignorespace nasconde ogni comando digitato con uno spazio iniziale. Tutto questo è configurato in man bash, perché la cronologia è pensata per essere sotto il controllo dell'utente.
Registra ciò che è stato digitato, non ciò che è stato eseguito. Un alias o una funzione della shell fanno sì che il testo nel file non corrisponda al programma eseguito dal kernel.
Inoltre, non sono presenti timestamp, a meno che HISTTIMEFORMAT non fosse impostata quando la voce è stata scritta, perché bash scrive le proprie righe marcatore #1755043200 solo quando quella variabile è impostata.
Su un login condiviso non può nemmeno indicare chi ha eseguito un'azione. Tre persone che usano un account deploy producono un unico file con le voci intercalate e associate a un solo uid. Nessun livello di logging può attribuire un'azione a una persona quando due persone condividono lo stesso uid. Questo è il motivo pratico per usare un account non privilegiato per ogni persona invece di un login condiviso.
La cronologia della shell è utile per il suo scopo reale: aiutare a ridigitare il comando di ieri. Usala come indicazione. Non presentarla mai come prova.
Cosa registra sudo e dove si interrompe
sudo invia una riga per ogni comando eseguito alla facility syslog authpriv.
sudo grep 'sudo:' /var/log/auth.log | tail -5
journalctl -t sudo -n 5Ogni riga indica l'utente, il terminale, la directory di lavoro, l'utente di destinazione e il comando:
sudo: alice : TTY=pts/0 ; PWD=/home/alice ; USER=root ; COMMAND=/usr/bin/apt updateSe /var/log/auth.log non esiste, rsyslog non è installato su quell'immagine e gli stessi record sono disponibili soltanto nel journal. Verifica che il journal non sia volatile prima di farvi affidamento:
journalctl --list-bootsLa presenza del solo boot corrente indica che /var/log/journal non esiste. Il journal si trova quindi in /run e tutte le righe vengono perse al riavvio successivo. Rendilo persistente:
sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journaldOra il limite. sudo registra il comando che gli è stato chiesto di eseguire. Non registra ciò che quel comando esegue in seguito. Una sola riga interrompe quindi la traccia:
sudo -iIl log contiene un solo record relativo alla shell. Ogni comando digitato all'interno di quella shell root è invisibile a sudo, perché sudo non si trova più nel percorso di esecuzione. sudo su -, sudo bash e sudo vim /etc/shadow seguiti da :!bash hanno tutti la stessa struttura. Una regola sudoers che consente l'esecuzione di qualsiasi programma con un'uscita verso una shell, come vim o find, equivale a concedere accesso root senza logging. Verifica quali risorse un account può raggiungere effettivamente prima di considerare affidabili le relative righe di log:
sudo -l -U aliceRegistrare una sessione completa per un account
Per prima cosa verifica quale versione di sudo è installata, perché questa funzionalità non esiste nella riscrittura in Rust:
sudo --version | head -1Se l'output indica sudo-rs, salta questa sezione e usa il sottosistema di auditing. La documentazione ufficiale di Ubuntu per le release 25.10 e 26.04 indica la registrazione dell'I/O e sudoreplay come non supportati; questa limitazione era ancora presente a ottobre 2026. È importante perché in queste release sudo-rs è il valore predefinito di sudo, quindi un aggiornamento può rimuovere un controllo che ritenevi disponibile. L'elenco completo delle modifiche al comportamento di sudo-rs merita una lettura prima di pianificare la registrazione basata su sudo.
Con il sudo originale, ancora incluso in Ubuntu 24.04 LTS, abilita la registrazione dell'I/O per un account:
sudo visudo -f /etc/sudoers.d/iologDefaults:deploy log_output
Defaults!/usr/bin/sudoreplay !log_outputUsa visudo invece di un editor, perché rifiuta di salvare un file con sintassi non valida. Un file sudoers danneggiato impedisce a tutti di usare sudo. Poi riproduci una sessione:
sudo sudoreplay -l user=deploy
sudo sudoreplay 000001sudoreplay -l elenca le sessioni con i relativi ID e non stampa nulla se log_output non è mai stato applicato a quell'utente. Il costo: ogni byte che attraversa il terminale viene memorizzato in /var/log/sudo-io, quindi una sessione verbosa può diventare voluminosa. La seconda riga di sudoers impedisce che una riproduzione venga registrata a sua volta. Il vero rischio riguarda i secret, perché un log dell'I/O contiene tutto ciò che è stato digitato e visualizzato, inclusa una password inserita in un prompt all'interno della sessione. Deve quindi essere protetto come un archivio di password. Anche la copertura è limitata. Vengono rilevati i comandi eseguiti tramite sudo. Chi accede e lavora sempre con il proprio account non viene registrato.
Hook della shell e come vengono aggirati esattamente
La procedura che circola per «registrare ogni comando» consiste nell'inserire un hook PROMPT_COMMAND in /etc/profile.d/:
# /etc/profile.d/00-cmdlog.sh
PROMPT_COMMAND='logger -p local6.info -t cmdlog "$(whoami) $$ $(history 1 | sed "s/^ *[0-9]* *//")"'bash esegue PROMPT_COMMAND prima di visualizzare ogni prompt. In questo modo la riga viene inviata a syslog mentre viene digitata, non alla chiusura della shell. logger scrive tramite il demone di log del sistema, quindi i permessi dell'utente sul proprio file non sono rilevanti. Apri una nuova shell di login e verifica con sudo tail -f /var/log/syslog oppure con journalctl -t cmdlog -f su un'immagine che non include rsyslog.
Poi smette di funzionare in cinque modi, ciascuno riproducibile in un minuto.
- Le shell non interattive non visualizzano un prompt.
ssh you@server 'id'esegue il comando e termina, senza registrare nulla, perchéPROMPT_COMMANDnon è mai stato valutato. - È una variabile.
unset PROMPT_COMMANDla disabilita per il resto della sessione e non richiede privilegi. - Il file viene letto dalle shell di login.
bash --noprofile --norcnon esegue mai il source di/etc/profile.d/. - È specifico di bash.
zsh,sh,python3 -c 'import os; os.system("id")'e:!idall'interno divimeseguono programmi che nessun hook del prompt di bash potrà intercettare. - Registra la riga così come viene digitata. Un alias o una funzione può quindi nascondere il comando eseguito realmente.
Usa un hook della shell come funzione di praticità. Può rispondere alla domanda «che cosa ho eseguito martedì scorso» per gli utenti collaborativi. Non considerarlo un controllo solo perché compare in una checklist.
Il sottosistema di audit del kernel rileva ogni chiamata execve
Il sottosistema di audit di Linux, gestito dal demone auditd, è l’unico livello che un utente non può aggirare, perché il record viene creato nel kernel nel momento in cui viene eseguita la syscall. Se un processo esegue un programma, viene generato un evento. La shell, il linguaggio e la presenza di un terminale non fanno alcuna differenza.
sudo apt update && sudo apt install -y auditd audispd-plugins
sudo systemctl enable --now auditd
sudo auditctl -sauditctl -s visualizza lo stato del demone. enabled 1 con un pid diverso da zero indica che è in esecuzione, mentre lost 0 indica che finora non è stato scartato alcun record. Ricorda quel contatore lost: tornerà più avanti.
auid è il campo che rende utile audit. PAM imposta un login uid quando inizia una sessione e, da quel momento, il kernel lo conserva in ogni processo figlio. Verifica il tuo:
cat /proc/self/loginuidUna sessione SSH interattiva stampa il tuo uid, perché /etc/pam.d/sshd include pam_loginuid.so. Un valore 4294967295 indica che loginuid non è mai stato impostato; è normale per un processo avviato da un demone di sistema durante il boot. L'aspetto importante è che sudo -i non lo modifica: una shell root aperta da alice mantiene auid 1000, quindi ogni comando eseguito al suo interno è riconducibile ad alice. È esattamente la lacuna lasciata aperta da sudo. Per modificare un loginuid già impostato serve CAP_AUDIT_CONTROL, che gli utenti normali non possono usare, mentre sudo auditctl --loginuid-immutable impedisce la modifica anche a root fino al riavvio successivo.
Verifica che /etc/pam.d/sshd, /etc/pam.d/login e /etc/pam.d/cron includano ciascuno pam_loginuid.so. In caso contrario, gli eventi arriveranno senza alcun processo associato. Si tratta dello stesso elenco di file che modifichi quando rafforzi l’accesso SSH su un VPS, quindi esegui entrambe le attività insieme.
Un set di regole iniziale per auditd
Le regole si trovano in /etc/audit/rules.d/*.rules. augenrules le concatena in un unico elenco, nell’ordine dei nomi dei file. L’ordine determina il comportamento, perché il kernel si ferma alla prima regola corrispondente. Leggete ciò che è già presente prima di aggiungere nuove regole, perché un -D in un file successivo annulla tutto ciò che è stato caricato prima.
ls /etc/audit/rules.d/
cat /etc/audit/rules.d/audit.rulesQuindi scrivete /etc/audit/rules.d/50-exec.rules:
## Suppressions first: the kernel takes the first matching rule.
-a never,exit -F arch=b64 -S execve -F exe=/usr/bin/dpkg
-a never,exit -F arch=b64 -S execve -F exe=/usr/bin/dpkg-deb
-a never,exit -F arch=b64 -S execve -F exe=/usr/bin/dpkg-query
-a never,exit -F arch=b64 -S execve -F exe=/usr/bin/dpkg-split
-a never,exit -F arch=b64 -S execve -F exe=/usr/bin/dpkg-trigger
## Every program started by a logged-in human.
-a always,exit -F arch=b64 -S execve,execveat -F auid>=1000 -F auid!=unset -k exec
-a always,exit -F arch=b32 -S execve,execveat -F auid>=1000 -F auid!=unset -k exec
## Changes to who may become root.
-w /etc/sudoers -p wa -k sudoers
-w /etc/sudoers.d/ -p wa -k sudoers
-w /etc/passwd -p wa -k identity
-w /etc/shadow -p wa -k identity
-w /etc/group -p wa -k identity
## Changes to the audit configuration itself.
-w /etc/audit/ -p wa -k auditconfigCaricate le regole e verificate il risultato:
sudo augenrules --load
sudo auditctl -lauditctl -l, che ristampa le regole, indica che sono attive. No rules indica che il caricamento non è riuscito, mentre journalctl -u auditd -n 20 specifica il file e la riga rifiutata dal parser. Le versioni meno recenti dello userspace di audit non riconoscono la parola chiave unset. Se il loader segnala un errore relativo a quel campo, scrivete invece -F auid!=4294967295, che esprime lo stesso valore per esteso.
Ora leggete gli eventi:
sudo ausearch -k exec -ts recent -i | tail -40
sudo ausearch -ul 1000 -ts today -i
sudo aureport -k --summary -i-i converte gli UID e i numeri delle syscall nei rispettivi nomi; nella pratica è indispensabile. -ts recent include gli ultimi dieci minuti. Ogni esecuzione viene registrata come un gruppo di record: un record SYSCALL con UID, AUID, stato di uscita e chiave, un record EXECVE con l’elenco completo degli argomenti, oltre ai record CWD e PATH per il contesto.
È importante considerare un limite che spesso causa errori di interpretazione. audit registra le syscall, ma un builtin della shell non esegue alcuna syscall propria. cd /root non avvia alcun programma. Anche echo evil >> /etc/passwd, digitato al prompt di bash, non avvia alcun programma, perché sia echo sia il redirect vengono eseguiti all’interno del processo della shell già in esecuzione. Pertanto le regole execve rilevano i programmi, mentre le regole -w rilevano le scritture. Nessuno dei due insiemi è sufficiente da solo.
Infine, rendete immutabile la configurazione:
## /etc/audit/rules.d/99-finalize.rules
-e 2-e 2 rende il set di regole immutabile fino al riavvio successivo. Dopo il caricamento, auditctl -s restituisce enabled 2 e ogni tentativo di aggiungere o eliminare una regola fallisce con Operation not permitted, anche se eseguito da root. Aggiungete questo file per ultimo e prevedete un riavvio ogni volta che dovete modificare una regola. Questo compromesso è il punto essenziale: un set di regole che chiunque può disattivare senza lasciare traccia non costituisce una prova.
Un log di audit che nessuno legge è un artefatto di conformità
Il problema di auditd non è che perda degli eventi. È che ne registra così tanti che nessuno li consulta, quindi il log serve a soddisfare una checklist invece di rispondere a una domanda.
Prima di modificare qualsiasi impostazione, fai questi calcoli sul tuo server:
sudo aureport -k --summary -i
sudo du -sh /var/log/auditUn singolo sudo apt upgrade avvia migliaia di processi di breve durata, e ognuno conserva il tuo auid. Un aggiornamento di un pacchetto può quindi produrre più eventi di una settimana di attività umana. Per questo le esclusioni indicate sopra specificano dpkg e i relativi helper. Escludi in base all'eseguibile, mai in base all'utente: un'esclusione per /usr/bin/dpkg è una lacuna che puoi descrivere in una frase, mentre un'esclusione per un account ha esattamente la forma dell'elemento che stavi cercando di rilevare.
La chiave -k presente in ogni regola rende il log consultabile anche un mese dopo. ausearch -k sudoers è una domanda con una risposta. ausearch senza filtri è un muro di testo che ti porta a smettere di leggere. Se il tuo collector richiede JSON invece del formato nativo, laurel è un plugin di auditd che riscrive ogni evento come un singolo oggetto JSON, decodificando gli argomenti. Viene registrato in /etc/audit/plugins.d/ come qualsiasi altro plugin, e auditd applica le modifiche ai plugin al sudo pkill -HUP auditd.
Quanto costa auditd, in termini realistici
Ogni syscall che corrisponde a una regola diventa un record che il kernel formatta e passa allo userspace. Il costo si manifesta in due aree, entrambe misurabili sul proprio carico di lavoro invece di essere stimate a partire da un numero pubblicato da altri.
- CPU e latenza. Una macchina che crea continuamente processi con fork, un host di build o un runner CI genera un record per ogni exec. Quando il backlog del kernel si riempie,
--backlog_wait_timefa sospendere il processo che ha generato l'evento finché non si libera spazio. Di conseguenza, audit si manifesta come rallentamento delle build, non come una percentuale di utilizzo della CPU. Durante un carico reale, controllarebacklogelostinsudo auditctl -s. Un valore crescente dilostindica che i record sono stati persi. Un log con lacune non segnalate è peggiore dell'assenza di log, perché continuerai comunque a considerarlo affidabile. - Disco. Leggere
/etc/audit/auditd.confe decidere consapevolmente cosa deve accadere quando il disco si riempie, perché i valori forniti con il software riflettono scelte predefinite.max_log_file,num_logsemax_log_file_actioncontrollano la rotazione.space_left_action,admin_space_left_actionedisk_full_actioncontrollano la gestione delle emergenze. Alcune azioni disponibili, tra cuihaltesingle, arrestano la macchina invece di perdere un record.
La riga -f in /etc/audit/rules.d/audit.rules esprime la stessa decisione a livello del kernel: -f 1 segnala un errore di audit a syslog, mentre -f 2 manda il kernel in panic. Scegliere 2 è appropriato solo se si preferisce davvero perdere il server invece di perdere un record. Su un VPS che esegue un servizio da cui dipendono gli utenti, è preferibile ruotare i log e spostare il problema dello spazio di archiviazione fuori dalla macchina.
Inviare i log fuori dal server quasi in tempo reale
È l’aspetto che i rapporti sugli incidenti continuano a confermare. I log che restano sull’host compromesso possono essere modificati da chi lo ha violato. root può riscrivere /var/log/auth.log, eliminare /var/log/audit/audit.log e arrestare il demone. -e 2 impedisce di scaricare le regole. Non protegge rm. Ogni livello superiore produce prove soltanto se una copia lascia prima la macchina.
Il trasporto integrato di Audit è il plugin audisp-remote di audispd-plugins. Attivatelo in /etc/audit/plugins.d/au-remote.conf:
active = yes
direction = out
path = /usr/sbin/audisp-remote
type = always
format = stringVerificate path rispetto a command -v audisp-remote prima di ricaricare la configurazione, perché un percorso errato produce soltanto una riga nel journal. Impostate remote_server e port in /etc/audit/audisp-remote.conf e, sul collector, impostate tcp_listen_port = 60 nel relativo auditd.conf. Ricaricate con sudo pkill -HUP auditd. Su molte immagini systemctl restart auditd viene rifiutato, perché il file dell'unità imposta RefuseManualStop=yes; per questo il segnale è il metodo più affidabile.
L'altra opzione inserisce Audit nel flusso syslog che già inoltrate. /etc/audit/plugins.d/syslog.conf viene fornito con active = no. Impostatelo su yes, ricaricate la configurazione e gli eventi di Audit verranno aggiunti alle righe di sudo e a tutto il resto. Quindi inoltrate l'intero flusso con rsyslog tramite TLS (Transport Layer Security), che richiede il pacchetto rsyslog-gnutls:
# /etc/rsyslog.d/60-forward.conf
*.* action(type="omfwd"
target="logs.example.net" port="6514" protocol="tcp"
StreamDriver="gtls" StreamDriverMode="1"
StreamDriverAuthMode="x509/name"
StreamDriverPermittedPeers="logs.example.net"
action.resumeRetryCount="-1"
queue.type="linkedList" queue.filename="fwd" queue.saveOnShutdown="on")La parte più importante riguarda le impostazioni della coda. action.resumeRetryCount="-1" ritenta senza limiti e la coda assistita dal disco, con queue.saveOnShutdown="on", conserva i record mentre il collector non è raggiungibile, quindi li invia quando torna disponibile. Senza queste due impostazioni, un riavvio del collector crea un vuoto nelle prove raccolte e non lascia alcuna indicazione della sua presenza. Applicate la configurazione con sudo systemctl restart rsyslog, quindi verificate che i record arrivino effettivamente sul collector prima di considerare affidabile il sistema.
Resta da chiudere un ultimo punto: il collector deve essere una macchina sulla quale le persone sottoposte ad audit non possano accedere. Se lo stesso gruppo di amministratori dispone di root sul server dei log, avete copiato il file, ma non lo avete protetto. Usate credenziali separate, chiavi separate e, idealmente, un account separato presso il provider. È lo stesso principio per cui vale la pena predisporre un metodo centralizzato per gestire molti server Linux prima di averne bisogno; ed è ciò che fa la differenza tra una prima ora utile e una prima ora sprecata quando state gestendo un VPS compromesso.
Verificare che un utente normale non possa riscrivere il record
Verificate l'affermazione invece di darla per scontata. Da un account ordinario, senza sudo:
echo test >> /var/log/auth.log
cat /var/log/audit/audit.log
auditctl -D
id -nGIn ordine, aspettatevi: Permission denied, perché auth.log appartiene a syslog, ha il gruppo adm e i permessi 640; di nuovo Permission denied, perché l'audit log ha permessi 600 e appartiene a root; un errore che impedisce l'esecuzione, perché per modificare le regole di audit è necessario CAP_AUDIT_CONTROL; e un elenco dei gruppi che non contiene né adm né systemd-journal.
Quest'ultimo controllo è quello che spesso viene omesso. L'appartenenza a adm concede l'accesso in lettura a /var/log/auth.log, mentre l'appartenenza a systemd-journal concede l'accesso in lettura all'intero journal. Nessuno dei due gruppi concede l'accesso in scrittura, quindi nessuno dei due consente di alterare i dati. Entrambi permettono di leggere ogni riga di autenticazione del server. È una scelta da effettuare consapevolmente, non copiando una riga usermod -aG da una risposta trovata in un forum.
Infine, verificate che due condizioni necessarie resistano al riavvio:
sudo auditctl -s
systemctl is-enabled auditdenabled 2 significa che il set di regole resta bloccato fino al successivo avvio. enabled, restituito dal secondo comando, indica che auditd viene avviato di nuovo dopo quel riavvio. Un set di regole che resta attivo solo fino al successivo aggiornamento del kernel non costituisce un audit trail.
FAQ
Come posso visualizzare tutti i comandi eseguiti da un utente specifico?
Individua il suo uid con id -u alice, quindi cerca nel log di audit usando il login uid: sudo ausearch -ul 1000 -ts today -i. Aggiungi -k exec per limitare la ricerca alla regola execve. Il login uid viene impostato al login e rimane invariato attraverso su e sudo -i, quindi vengono rilevati anche i comandi eseguiti in una shell root aperta da quell'account. Funziona solo per i comandi eseguiti dopo il caricamento delle regole, perché audit non conserva la cronologia degli eventi per i quali non era configurato per registrare. sudo aureport -k --summary -i mostra i conteggi per regola, se vuoi esaminare prima la distribuzione dei dati.
Un utente può eliminare la cronologia di bash per nascondere ciò che ha eseguito?
Sì, senza bisogno di privilegi. ~/.bash_history appartiene all'utente e ha modalità 600, quindi l'utente può modificarlo, svuotarlo o eliminarlo. Può anche impedire che venga scritto usando unset HISTFILE, interrompere la registrazione durante la sessione con set +o history oppure nascondere singoli comandi digitandoli con uno spazio iniziale quando HISTCONTROL=ignorespace è impostato. Bash scrive il file quando la shell termina, quindi una sessione terminata con kill -9 $$ non registra nulla. Una connessione interrotta non basta a nascondere le attività, perché bash salva la cronologia al ricevimento del SIGHUP generato dalla disconnessione. Considera la cronologia della shell solo come un'indicazione, mai come una prova.
sudo registra ciò che accade dentro sudo -i?
No. sudo registra il comando che gli è stato chiesto di eseguire, quindi sudo -i produce una riga per la shell e nulla per i comandi successivi. Ogni comando digitato in quella shell root non è visibile a sudo, perché sudo non viene più coinvolto. sudo su -, sudo bash e qualsiasi programma autorizzato con una shell escape si comportano allo stesso modo. Due misure colmano questa lacuna: regole di audit su execve, che registrano ogni programma associandolo al login uid originale, e regole sudoers che non concedono una shell fin dall'inizio.
auditd rallenterà il server?
Dipende interamente dal numero di processi avviati dal carico di lavoro, quindi misuralo invece di affidarti a un valore indicativo. Un server che risponde soprattutto alle richieste esegue pochi processi e non noterà differenze. Un host di build o un runner CI esegue continuamente nuovi processi e può subire un rallentamento significativo, perché quando il backlog di audit del kernel si riempie, il processo che ha generato l'evento viene sospeso finché non si libera spazio. Esegui sudo auditctl -s sotto un carico reale e monitora backlog e lost. Qualsiasi lost superiore a zero indica che sono stati persi dei record. È lo scenario peggiore, perché nel log ora esistono lacune non visibili.
Dove devono essere archiviati i log di audit?
Su un'altra macchina, con un ritardo misurato in secondi. Chiunque ottenga root sull'host sottoposto ad audit può eliminare /var/log/audit/audit.log e riscrivere /var/log/auth.log, quindi le copie locali consentono di analizzare soltanto gli incidenti che nessuno ha cercato di nascondere. Inoltra i log con il plugin audisp-remote a un'istanza centrale di auditd oppure abilita il plugin syslog di audit e inoltra l'intero flusso syslog con rsyslog tramite TLS. Assegna al collector credenziali proprie e assicurati che gli account sottoposti ad audit non possano accedervi.