Comment auditer les commandes exécutées sur un serveur
L’historique shell n’est pas une preuve. Comparez sudo, l’enregistrement de session, les hooks shell et auditd execve, puis envoyez les logs hors serveur.
Ce qui enregistre réellement les commandes exécutées par les utilisateurs sur votre serveur
Pour auditer les commandes exécutées par les utilisateurs sur votre serveur, vous avez besoin d’un enregistrement que l’utilisateur ne peut pas modifier. L’historique du shell ne convient pas. Il s’agit d’un fichier de commodité appartenant au compte qui l’a écrit. Toute personne pouvant saisir des commandes dans ce shell peut le désactiver ou le supprimer.
Quatre couches permettent de conserver un véritable enregistrement, avec un coût différent pour chacune. sudo écrit une ligne par commande dans syslog. La journalisation des E/S de sudo capture toute une session pour un compte. Un hook du shell tel que PROMPT_COMMAND journalise ce qu’un utilisateur interactif de bash saisit. Le sous-système d’audit du noyau enregistre l’appel système execve lui-même. C’est pourquoi il s’agit de la seule couche qui voit chaque processus. Ce guide présente ces couches dans l’ordre, indique les limites de chacune et termine par l’élément qui détermine leur réelle utilité : transférer les enregistrements hors de la machine avant que la personne auditée puisse y accéder.
Un avertissement avant de commencer. Le sous-système d’audit repose sur le noyau. Il est donc impossible de le tester dans un conteneur qui partage le noyau de l’hôte. Exécutez ces commandes sur un VPS KVM dont vous contrôlez le noyau.
Pourquoi l’historique du shell ne constitue pas une piste d’audit
~/.bash_history échoue comme élément de preuve pour quatre raisons courantes. Aucune ne nécessite un attaquant particulièrement habile.
Il appartient à l’utilisateur. Le fichier a le mode 600 et appartient à ce compte. rm ~/.bash_history ne nécessite donc aucun privilège. Il suffit également de l’ouvrir dans un éditeur et de supprimer les vingt lignes importantes.
Il est écrit à la fermeture du shell. Une session qui se termine par kill -9 $$ n’écrit rien, car SIGKILL ne peut pas être intercepté et bash n’a pas le temps d’enregistrer l’historique. history -c avant exit produit le même effet et donne l’impression que rien ne s’est passé. Une connexion interrompue est différente : la déconnexion envoie SIGHUP au shell interactif, et bash enregistre volontairement son historique à la réception de SIGHUP et de SIGTERM avant de quitter. Une session SSH perdue laisse donc bien ses lignes derrière elle, sauf si l’historique a été désactivé.
Il suffit d’un mot pour le désactiver. unset HISTFILE empêche l’écriture du fichier pour cette session. set +o history arrête immédiatement l’enregistrement. HISTCONTROL=ignorespace masque toutes les commandes saisies avec une espace initiale. Tout cela se trouve dans man bash, car ce comportement est conçu pour être contrôlé par l’utilisateur.
Il enregistre ce qui a été saisi, pas ce qui a été exécuté. Un alias ou une fonction shell signifie que le texte du fichier ne correspond pas au programme exécuté par le kernel.
Les horodatages sont également absents, sauf si HISTTIMEFORMAT était défini au moment de l’écriture de l’entrée, car bash n’écrit ses lignes de marqueur #1755043200 que lorsque cette variable est définie.
Sur un login partagé, l’historique ne permet pas non plus de savoir qui a exécuté une commande. Trois personnes utilisant un même compte deploy produisent un seul fichier entrelacé sous un seul uid. Aucune couche de journalisation ne peut attribuer une action à une personne lorsque deux personnes partagent un uid. C’est l’argument pratique en faveur de un compte non privilégié par personne plutôt qu’un login partagé.
L’historique du shell remplit correctement sa fonction réelle : vous aider à retaper la commande d’hier. Utilisez-le comme indice. Ne le présentez jamais comme une preuve.
Ce que journalise sudo et où la trace s’arrête
sudo envoie une ligne pour chaque commande qu’il exécute à la facility syslog authpriv.
sudo grep 'sudo:' /var/log/auth.log | tail -5
journalctl -t sudo -n 5Chaque ligne indique l’utilisateur, le terminal, le répertoire de travail, l’utilisateur cible et la commande :
sudo: alice : TTY=pts/0 ; PWD=/home/alice ; USER=root ; COMMAND=/usr/bin/apt updateSi /var/log/auth.log n’existe pas, rsyslog n’est pas installé sur cette image et les mêmes enregistrements se trouvent uniquement dans le journal. Vérifiez que le journal n’est pas volatile avant de vous y fier :
journalctl --list-bootsLe fait que seul le boot courant soit listé signifie que /var/log/journal n’existe pas. Le journal se trouve donc dans /run et chaque ligne est perdue au redémarrage suivant. Rendez-le persistant :
sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journaldPassons à la limite. sudo journalise la commande qu’on lui demande d’exécuter. Il ne journalise pas ce que cette commande fait ensuite. Une seule ligne suffit donc à interrompre la trace :
sudo -iLe journal ne contient qu’un seul enregistrement pour le shell. Chaque commande saisie dans ce shell root est invisible pour sudo, car sudo n’est plus sur le chemin d’exécution. sudo su -, sudo bash et sudo vim /etc/shadow suivis de :!bash ont tous la même structure. Une règle sudoers qui autorise un programme permettant d’échapper vers un shell, comme vim ou find, accorde en pratique un accès root non journalisé. Vérifiez ce qu’un compte peut réellement exécuter avant de vous fier à ses lignes de journal :
sudo -l -U aliceEnregistrer une session complète pour un compte
Commencez par vérifier quelle version de sudo est installée, car cette fonctionnalité n’existe pas dans la réécriture Rust :
sudo --version | head -1Si la sortie indique sudo-rs, ignorez cette section et utilisez le sous-système d’audit. La documentation officielle d’Ubuntu pour les versions 25.10 et 26.04 indique que la journalisation des entrées-sorties et sudoreplay ne sont pas pris en charge. C’était toujours le cas en octobre 2026. Ce point est important, car sudo-rs est le sudo par défaut dans ces versions. Une mise à niveau peut donc supprimer un contrôle que vous pensiez avoir. La liste complète des changements de comportement de sudo-rs mérite d’être consultée avant de prévoir une journalisation basée sur sudo.
Avec sudo d’origine, toujours fourni par Ubuntu 24.04 LTS, activez la journalisation des entrées-sorties pour un compte :
sudo visudo -f /etc/sudoers.d/iologDefaults:deploy log_output
Defaults!/usr/bin/sudoreplay !log_outputUtilisez visudo plutôt qu’un éditeur, car cette commande refuse d’enregistrer un fichier dont la syntaxe est invalide. Un fichier sudoers incorrect empêche tout le monde d’utiliser sudo. Relisez ensuite une session :
sudo sudoreplay -l user=deploy
sudo sudoreplay 000001sudoreplay -l répertorie les sessions avec leurs identifiants et n’affiche rien si log_output ne s’est jamais appliqué à cet utilisateur. Le coût : chaque octet qui transite par le terminal est enregistré sous /var/log/sudo-io. Une session verbeuse occupe donc beaucoup d’espace. La deuxième ligne sudoers empêche l’enregistrement d’une relecture. Le véritable risque concerne les secrets, car un journal d’entrées-sorties contient tout ce qui a été saisi et affiché, notamment un mot de passe saisi dans une invite au sein de la session. Il doit donc être protégé comme un gestionnaire de mots de passe. La couverture est également limitée. La fonctionnalité voit les commandes exécutées avec sudo. Une personne qui se connecte et travaille entièrement avec son propre compte n’est pas enregistrée.
Hooks shell et méthode exacte pour les contourner
La recette qui circule pour « journaliser chaque commande » consiste à déposer un hook PROMPT_COMMAND dans /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 exécute PROMPT_COMMAND avant d’afficher chaque invite. La ligne est donc envoyée à syslog dès sa saisie, et non à la fermeture du shell. logger écrit via le daemon de journalisation système. Les permissions du fichier de l’utilisateur n’interviennent donc pas. Ouvrez un nouveau shell de connexion et vérifiez avec sudo tail -f /var/log/syslog, ou avec journalctl -t cmdlog -f sur une image qui n’utilise pas rsyslog.
Puis cette méthode cesse de fonctionner, de cinq façons que vous pouvez reproduire chacune en une minute.
- Les shells non interactifs n’affichent jamais d’invite.
ssh you@server 'id'exécute la commande et se termine, sans rien journaliser, carPROMPT_COMMANDn’a jamais été évalué. - Il s’agit d’une variable.
unset PROMPT_COMMANDla désactive pour le reste de la session et ne nécessite aucun privilège. - Le fichier est lu par les shells de connexion.
bash --noprofile --norcne charge jamais/etc/profile.d/. - Cette méthode est propre à bash.
zsh,sh,python3 -c 'import os; os.system("id")'et:!iddansvimexécutent tous des programmes qu’aucun hook d’invite bash ne pourra voir. - La ligne est journalisée telle qu’elle est saisie. Un alias ou une fonction peut donc toujours masquer la commande réellement exécutée.
Utilisez un hook shell comme aide pratique. Il permet de répondre à la question « qu’ai-je exécuté mardi dernier ? » pour les utilisateurs coopératifs. Ne le présentez pas comme un contrôle dans une checklist.
Le sous-système d’audit du kernel voit chaque execve
Le sous-système d’audit Linux, piloté par le daemon auditd, est la seule couche que l’utilisateur ne peut pas contourner ici, car l’enregistrement est créé dans le kernel au moment où l’appel système s’exécute. Si un processus exécute un programme, un événement est généré. Le shell, le langage utilisé et la présence d’un terminal ne changent rien.
sudo apt update && sudo apt install -y auditd audispd-plugins
sudo systemctl enable --now auditd
sudo auditctl -sauditctl -s affiche l’état du daemon. enabled 1 avec une valeur non nulle pid indique qu’il fonctionne, et lost 0 signifie qu’aucun enregistrement n’a encore été perdu. Retenez ce compteur lost, car il réapparaîtra plus loin.
auid est le champ qui justifie l’utilisation de l’audit. PAM définit un uid de connexion au démarrage d’une session, puis le kernel le transmet à chaque processus enfant. Vérifiez le vôtre :
cat /proc/self/loginuidUne session SSH interactive affiche votre uid, car /etc/pam.d/sshd inclut pam_loginuid.so. La valeur 4294967295 signifie que le loginuid n’a jamais été défini, ce qui est normal pour un processus lancé par un daemon système au boot. Le point important est que sudo -i ne le modifie pas : un shell root ouvert par alice conserve l’auid 1000. Chaque commande exécutée dans ce shell reste donc attribuable à alice. C’est précisément la lacune laissée par sudo. Modifier un loginuid déjà défini nécessite CAP_AUDIT_CONTROL, dont les utilisateurs ordinaires ne disposent pas, et sudo auditctl --loginuid-immutable empêche également root de le modifier jusqu’au prochain reboot.
Vérifiez que /etc/pam.d/sshd, /etc/pam.d/login et /etc/pam.d/cron incluent chacun pam_loginuid.so, sinon les événements arriveront sans utilisateur associé. Il s’agit de la même liste de fichiers que celle que vous modifiez pour renforcer l’accès SSH sur un VPS. Effectuez donc les deux opérations ensemble.
Règles de base pour auditd
Les règles se trouvent dans /etc/audit/rules.d/*.rules. augenrules les concatène dans l’ordre des noms de fichiers pour former une seule liste. L’ordre détermine le comportement, car le noyau s’arrête à la première règle correspondante. Consultez d’abord le contenu existant avant d’ajouter quoi que ce soit, car un -D dans un fichier chargé plus tard supprime tout ce qui a été chargé auparavant.
ls /etc/audit/rules.d/
cat /etc/audit/rules.d/audit.rulesÉcrivez ensuite /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 auditconfigChargez les règles et vérifiez le résultat :
sudo augenrules --load
sudo auditctl -lauditctl -l affiche à nouveau vos règles, ce qui signifie qu’elles sont actives. No rules signifie que le chargement a échoué, et journalctl -u auditd -n 20 indique le fichier et la ligne rejetés par l’analyseur. Les anciennes versions de l’espace utilisateur audit ne comprennent pas le mot-clé unset. Si le chargeur signale un problème avec ce champ, écrivez plutôt -F auid!=4294967295, qui correspond à la même valeur en toutes lettres.
Lisez maintenant les événements :
sudo ausearch -k exec -ts recent -i | tail -40
sudo ausearch -ul 1000 -ts today -i
sudo aureport -k --summary -i-i convertit les UID et les numéros d’appels système en noms. En pratique, cette option est indispensable. -ts recent couvre les dix dernières minutes. Chaque exécution produit un groupe d’enregistrements : un enregistrement SYSCALL contenant l’UID, l’AUID, le code de sortie et la clé, un enregistrement EXECVE avec la liste complète des arguments, ainsi que des enregistrements CWD et PATH fournissant le contexte.
Voici une limite importante, qui surprend souvent. audit enregistre les appels système, mais une builtin du shell n’effectue aucun appel système qui lui soit propre. cd /root n’exécute aucun programme. echo evil >> /etc/passwd saisi à l’invite bash n’exécute pas non plus de programme, car le echo et la redirection s’effectuent dans le processus du shell déjà en cours. Les règles execve voient donc les programmes, tandis que les règles -w voient les écritures. Aucune des deux catégories ne suffit seule.
Enfin, verrouillez la configuration :
## /etc/audit/rules.d/99-finalize.rules
-e 2-e 2 rend le jeu de règles immuable jusqu’au prochain redémarrage. Une fois le chargement effectué, auditctl -s renvoie enabled 2, et toute tentative d’ajout ou de suppression d’une règle échoue avec Operation not permitted, y compris pour root. Ajoutez ce fichier en dernier et prévoyez un redémarrage chaque fois que vous voulez modifier une règle. C’est précisément l’objectif de ce compromis : un jeu de règles que n’importe qui peut désactiver discrètement ne constitue pas une preuve.
Un journal d’audit que personne ne lit est un artefact de conformité
Le problème d’auditd n’est pas qu’il oublie des événements. Il enregistre tellement d’informations que personne ne les consulte, et le journal finit par exister uniquement pour remplir une checklist au lieu de répondre à une question.
Faites le calcul sur votre propre serveur avant de modifier la configuration :
sudo aureport -k --summary -i
sudo du -sh /var/log/auditUn seul sudo apt upgrade lance des milliers de processus à courte durée de vie, et chacun d’eux reprend votre auid. Une seule mise à jour de paquet peut donc produire davantage d’événements qu’une semaine de saisie humaine. C’est pourquoi les règles de suppression ci-dessus ciblent dpkg et ses programmes auxiliaires. Excluez un exécutable, jamais un utilisateur : une exclusion pour /usr/bin/dpkg est une faille que vous pouvez décrire en une phrase, tandis qu’une exclusion pour un compte a exactement la forme de l’élément que vous essayiez d’intercepter.
La clé -k présente dans chaque règle permet d’effectuer des recherches dans le journal un mois plus tard. ausearch -k sudoers correspond à une question qui possède une réponse. ausearch sans filtre n’est qu’un mur de texte qui vous apprend à ne plus lire. Si votre collecteur attend du JSON plutôt que le format natif, laurel est un plugin auditd qui réécrit chaque événement sous la forme d’un objet JSON contenant les arguments décodés. Il s’enregistre dans /etc/audit/plugins.d/ comme n’importe quel autre plugin, et auditd applique les modifications des plugins lors de sudo pkill -HUP auditd.
Le coût réel d’auditd
Chaque syscall correspondant à une règle devient un enregistrement que le kernel formate et transmet à l’espace utilisateur. Le coût se répartit entre deux postes, que vous pouvez mesurer sur votre propre charge plutôt que d’estimer à partir d’une valeur publiée pour une autre machine.
- CPU et latence. Une machine qui crée constamment des processus, un serveur de build ou un runner CI, produit un enregistrement par exécution. Lorsque le backlog du kernel est plein,
--backlog_wait_timeforce le kernel à suspendre le processus à l’origine de l’événement jusqu’à ce qu’une place se libère. Audit se manifeste alors par des builds plus lents, et non par un pourcentage de CPU. Surveillezbacklogetlostdanssudo auditctl -spendant une charge réelle. Une valeurlosten hausse signifie que des enregistrements ont été perdus. Un journal comportant des trous silencieux est pire que l’absence de journal, car vous continuerez à lui faire confiance. - Disque. Lisez
/etc/audit/auditd.confet décidez explicitement du comportement lorsque le disque est plein, car les valeurs fournies par défaut reflètent des choix.max_log_file,num_logsetmax_log_file_actioncontrôlent la rotation.space_left_action,admin_space_left_actionetdisk_full_actioncontrôlent le comportement d’urgence. Certaines actions disponibles, notammenthaltetsingle, arrêtent la machine plutôt que de perdre un enregistrement.
La ligne -f dans /etc/audit/rules.d/audit.rules correspond à cette même décision au niveau du kernel : -f 1 signale un échec d’audit à syslog, tandis que -f 2 provoque un kernel panic. Choisissez 2 uniquement si vous préférez réellement perdre le serveur plutôt qu’un enregistrement. Sur un VPS qui exécute un service dont des utilisateurs dépendent, préférez la rotation et déportez le stockage hors de la machine.
Transférez les journaux hors du serveur, presque en temps réel
C’est ce que les rapports d’incident démontrent systématiquement. Les journaux qui restent sur l’hôte compromis peuvent être modifiés par la personne qui l’a compromis. root peut réécrire /var/log/auth.log, supprimer /var/log/audit/audit.log et arrêter le daemon. -e 2 empêche le déchargement des règles. Il ne protège pas rm. Toutes les couches précédentes ne produisent des éléments de preuve que si une copie quitte d’abord la machine.
Le transport intégré à Audit utilise le plugin audisp-remote de audispd-plugins. Activez-le dans /etc/audit/plugins.d/au-remote.conf :
active = yes
direction = out
path = /usr/sbin/audisp-remote
type = always
format = stringVérifiez path par rapport à command -v audisp-remote avant de recharger la configuration, car un chemin incorrect ne produit rien, à part une ligne dans le journal. Définissez remote_server et port dans /etc/audit/audisp-remote.conf, puis définissez tcp_listen_port = 60 dans son propre auditd.conf sur le collecteur. Rechargez avec sudo pkill -HUP auditd. Sur de nombreuses images, systemctl restart auditd est refusé, car le fichier d’unité définit RefuseManualStop=yes. Le signal constitue donc la méthode fiable.
L’autre option envoie Audit dans le flux syslog que vous transmettez déjà. /etc/audit/plugins.d/syslog.conf est fourni avec active = no. Définissez-le sur yes, rechargez la configuration, puis les événements Audit rejoindront les lignes de sudo et tous les autres messages. Transférez ensuite l’ensemble avec rsyslog sur TLS (Transport Layer Security). Le paquet rsyslog-gnutls est requis :
# /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")Les paramètres de file d’attente sont les plus importants. action.resumeRetryCount="-1" effectue des tentatives indéfiniment. La file d’attente assistée par disque, avec queue.saveOnShutdown="on", conserve les enregistrements lorsque le collecteur est inaccessible, puis les envoie lorsqu’il redevient disponible. Sans ces deux paramètres, un redémarrage du collecteur crée un trou dans vos éléments de preuve, sans aucun moyen de vous signaler son existence. Appliquez la configuration avec sudo systemctl restart rsyslog, puis vérifiez que les enregistrements arrivent bien sur le collecteur avant de considérer le dispositif comme fiable.
Il reste un point à régler : le collecteur doit être une machine sur laquelle les personnes auditées ne peuvent pas se connecter. Si le même groupe d’administrateurs détient root sur le serveur de journaux, vous avez copié le fichier, mais vous ne l’avez pas protégé. Utilisez des identifiants distincts, des clés distinctes et, idéalement, un compte fournisseur distinct. C’est le même raisonnement qui justifie la mise en place d’un moyen centralisé de gérer plusieurs serveurs Linux avant d’en avoir besoin. C’est aussi ce qui fait la différence entre une première heure utile et une première heure inutile lorsque vous intervenez sur un VPS compromis.
Vérifier qu’un utilisateur normal ne peut pas réécrire l’enregistrement
Testez cette affirmation au lieu de la supposer. Depuis un compte ordinaire, sans sudo :
echo test >> /var/log/auth.log
cat /var/log/audit/audit.log
auditctl -D
id -nGAttendez-vous, dans cet ordre, à : Permission denied, car auth.log appartient à syslog, avec le groupe adm et le mode 640 ; Permission denied à nouveau, car le journal d’audit est en mode 600 et appartient à root ; une erreur indiquant que l’exécution est refusée, car la modification des règles d’audit nécessite CAP_AUDIT_CONTROL ; et une liste de groupes ne contenant ni adm ni systemd-journal.
C’est la dernière vérification qui pose le plus souvent problème. L’appartenance à adm donne un accès en lecture à /var/log/auth.log, et l’appartenance à systemd-journal donne un accès en lecture à l’ensemble du journal. Aucune des deux ne donne un accès en écriture : elles ne permettent donc pas de falsifier les enregistrements. Elles permettent toutes deux de lire chaque ligne d’authentification de la machine. Il faut donc prendre cette décision volontairement, plutôt que de copier une ligne usermod -aG depuis une réponse de forum.
Enfin, vérifiez les deux éléments qui doivent survivre à un redémarrage :
sudo auditctl -s
systemctl is-enabled auditdenabled 2 signifie que l’ensemble de règles est verrouillé jusqu’au prochain démarrage. enabled, dans la deuxième commande, signifie qu’auditd redémarrera après ce démarrage. Un ensemble de règles qui ne tient que jusqu’à la prochaine mise à jour du kernel ne constitue pas non plus une piste d’audit.
FAQ
Comment afficher toutes les commandes exécutées par un utilisateur donné ?
Trouvez son uid avec id -u alice, puis recherchez dans le journal d’audit avec son uid de connexion : sudo ausearch -ul 1000 -ts today -i. Ajoutez -k exec pour limiter la recherche à la règle execve. L’uid de connexion est défini à l’ouverture de session et conservé par su et sudo -i. Cela permet donc de détecter les commandes exécutées dans un shell root ouvert par ce compte. Cette méthode ne fonctionne que pour les commandes exécutées après le chargement des règles, car audit ne conserve aucun historique des événements qu’il n’était pas configuré pour enregistrer. sudo aureport -k --summary -i affiche le nombre d’événements par règle si vous voulez d’abord voir la répartition des données.
Un utilisateur peut-il supprimer son historique bash pour masquer les commandes exécutées ?
Oui, sans privilège particulier. ~/.bash_history appartient à cet utilisateur et possède le mode 600. Il peut donc le modifier, le tronquer ou le supprimer. Il peut aussi empêcher son écriture avec unset HISTFILE, arrêter l’enregistrement en cours de session avec set +o history, ou masquer certaines commandes en les saisissant avec une espace initiale lorsque HISTCONTROL=ignorespace est défini. Bash écrit le fichier à la fermeture du shell. Une session terminée avec kill -9 $$ n’enregistre donc rien. Une connexion interrompue ne suffit pas à masquer l’activité, car bash sauvegarde l’historique lorsqu’il reçoit le SIGHUP envoyé par la déconnexion. Considérez l’historique du shell comme un indice, jamais comme une preuve.
sudo journalise-t-il ce qui se passe dans sudo -i ?
Non. sudo journalise la commande qu’il doit exécuter. Ainsi, sudo -i produit une seule ligne pour le shell, puis plus rien. Toutes les commandes saisies dans ce shell root sont invisibles pour sudo, car sudo n’intervient plus. sudo su -, sudo bash et tout programme autorisé qui permet de lancer un shell se comportent de la même manière. Deux mesures comblent cette lacune : des règles d’audit sur execve, qui enregistrent chaque programme avec l’uid de connexion d’origine, et des règles sudoers qui n’accordent pas de shell directement.
auditd va-t-il ralentir mon serveur ?
Cela dépend entièrement du nombre de processus lancés par votre charge. Mesurez donc l’impact au lieu de vous fier à une valeur théorique. Un serveur qui se contente principalement de répondre aux requêtes exécute peu de processus et ne subira généralement aucun ralentissement visible. Un serveur de build ou un runner CI exécute constamment des processus et peut subir un ralentissement important. Lorsque la file d’attente d’audit du noyau est pleine, le processus qui a généré l’événement est mis en pause jusqu’à ce qu’une place se libère. Exécutez sudo auditctl -s sous une charge réelle et surveillez backlog et lost. Toute valeur lost supérieure à zéro signifie que des enregistrements ont été perdus. C’est le pire résultat, car le journal contient alors des lacunes invisibles.
Où les journaux d’audit doivent-ils être stockés ?
Sur une autre machine, avec un délai de transmission de quelques secondes. Toute personne qui obtient root sur l’hôte audité peut supprimer /var/log/audit/audit.log et réécrire /var/log/auth.log. Les copies locales ne permettent donc d’analyser que les incidents que personne n’a tenté de dissimuler. Transférez les journaux avec le plugin audisp-remote vers un serveur auditd centralisé, ou activez le plugin syslog d’audit et transférez l’ensemble du flux syslog avec rsyslog sur TLS. Attribuez au collecteur ses propres identifiants et vérifiez que les comptes audités n’y ont pas accès.