SSD Nodes Learn Hosting plans →
Guías Matt ConnorPor Matt Connor · Actualizado 2026-10-22

Cómo auditar los comandos ejecutados en un servidor

El historial de shell no es una auditoría. Compare sudo, grabación de sesiones, hooks de shell y reglas auditd execve, y envíe los logs fuera del servidor.

Qué registra realmente los comandos que los usuarios ejecutaron en su servidor

Para auditar los comandos que los usuarios ejecutaron en su servidor, necesita un registro que el usuario no pueda editar. El historial de la shell no es ese registro. Es un archivo de conveniencia, propiedad de la cuenta que lo escribió, y cualquiera que pueda escribir en esa shell puede desactivarlo o borrarlo.

Existen cuatro capas que mantienen un registro real, y cada una tiene un coste. sudo escribe una línea por comando en syslog. El registro de E/S de sudo captura una sesión completa para una cuenta. Un hook de shell como PROMPT_COMMAND registra lo que un usuario de bash interactivo escribió. El subsistema de auditoría del kernel registra la llamada al sistema execve, razón por la cual es la única capa que ve todos los procesos. Esta guía asciende por esa escalera, indica dónde se detiene cada capa y termina con la parte que decide si algo de esto tiene valor: extraer los registros de la máquina antes de que la persona a la que está auditando pueda acceder a ellos.

Una advertencia antes de empezar. El subsistema de auditoría es trabajo del kernel, por lo que nada de esto puede probarse dentro de un contenedor que comparta el kernel del host. Ejecute estos comandos en un VPS KVM donde el kernel sea suyo.

Por qué el historial del shell no es un registro de auditoría

~/.bash_history no sirve como evidencia por cuatro motivos habituales, y ninguno requiere un atacante especialmente hábil.

Pertenece al usuario. El archivo tiene permisos 600 y pertenece a esa cuenta, por lo que rm ~/.bash_history no necesita ningún privilegio. Tampoco se necesita privilegio para abrirlo en un editor y eliminar las veinte líneas relevantes.

Se escribe cuando el shell termina. Una sesión que termina con kill -9 $$ no escribe nada, porque SIGKILL no se puede capturar y bash nunca tiene la oportunidad de guardar el historial. Ejecutar history -c antes de exit produce el mismo efecto y parece que no ha ocurrido nada. Una conexión interrumpida es diferente: la desconexión entrega SIGHUP al shell interactivo, y bash guarda deliberadamente el historial al recibir SIGHUP y SIGTERM antes de salir. Por tanto, una sesión SSH perdida sí deja sus líneas, a menos que el historial estuviera desactivado.

Se desactiva con una sola palabra. unset HISTFILE impide que se escriba el archivo durante esa sesión. set +o history detiene el registro de inmediato. HISTCONTROL=ignorespace oculta todos los comandos escritos con un espacio inicial. Todo esto se controla mediante man bash, porque está diseñado para estar bajo el control del usuario.

Registra lo que se escribió, no lo que se ejecutó. Un alias o una función del shell hacen que el texto del archivo no sea el programa que ejecutó el kernel.

Tampoco hay marcas de tiempo, a menos que HISTTIMEFORMAT se estableciera mientras se escribía la entrada, porque bash sólo escribe sus líneas de marca #1755043200 cuando esa variable está establecida.

En una cuenta de acceso compartida tampoco puede indicar quién ejecutó una acción. Tres personas que usan una misma cuenta deploy producen un único archivo intercalado bajo un mismo uid. Ninguna capa de registro puede atribuir una acción a una persona cuando dos personas comparten un uid. Este es el argumento práctico para usar una cuenta sin privilegios por persona en lugar de un acceso compartido.

El historial del shell es útil para su función real: ayudarle a volver a escribir el comando del día anterior. Úselo como indicio. Nunca lo presente como una prueba.

Qué registra sudo y dónde se detiene

sudo envía una línea por cada comando que ejecuta a la facilidad authpriv syslog.

sudo grep 'sudo:' /var/log/auth.log | tail -5
journalctl -t sudo -n 5

Cada línea indica el usuario, la terminal, el directorio de trabajo, el usuario de destino y el comando:

sudo:    alice : TTY=pts/0 ; PWD=/home/alice ; USER=root ; COMMAND=/usr/bin/apt update

Si /var/log/auth.log no existe, rsyslog no está instalado en esa imagen y los mismos registros se encuentran únicamente en el journal. Compruebe que el journal no sea volátil antes de confiar en él:

journalctl --list-boots

Si solo aparece el arranque actual, significa que /var/log/journal no existe, por lo que el journal reside en /run y cada línea se pierde en el siguiente reinicio. Hágalo persistente:

sudo mkdir -p /var/log/journal
sudo systemd-tmpfiles --create --prefix /var/log/journal
sudo systemctl restart systemd-journald

Ahora, el límite. sudo registra el comando que se le solicitó ejecutar. No registra lo que ese comando hace posteriormente. Por lo tanto, una línea termina el rastro:

sudo -i

El registro obtiene un único registro para la shell. Cada comando escrito dentro de esa shell de root es invisible para sudo, porque sudo ya no está en la ruta. sudo su -, sudo bash y sudo vim /etc/shadow seguidos de :!bash tienen todos la misma forma. Una regla de sudoers que permita cualquier programa con escape a shell, como vim o find, es una regla que otorga acceso root sin registro. Lea a qué puede acceder realmente una cuenta antes de confiar en sus líneas de registro:

sudo -l -U alice

Registrar una sesión completa para una cuenta

Primero averigüe qué implementación de sudo tiene, porque esta función no existe en la reescritura en Rust:

sudo --version | head -1

Si la salida indica sudo-rs, omita esta sección y use el subsistema de auditoría. La documentación oficial de Ubuntu para las versiones 25.10 y 26.04 indica que el registro de E/S y sudoreplay no son compatibles. Esto seguía siendo así en octubre de 2026. Es importante porque sudo-rs es el sudo predeterminado en esas versiones. Por tanto, una actualización puede eliminar un control que creía tener. La lista completa de cambios de comportamiento de sudo-rs merece una lectura antes de planificar cualquier registro basado en sudo.

Con el sudo original, que Ubuntu 24.04 LTS todavía incluye, active el registro de E/S para una cuenta:

sudo visudo -f /etc/sudoers.d/iolog
Defaults:deploy log_output
Defaults!/usr/bin/sudoreplay !log_output

Use visudo en lugar de un editor, porque se niega a guardar un archivo con una sintaxis no válida. Un archivo sudoers defectuoso impide que todos usen sudo. Después, reproduzca una sesión:

sudo sudoreplay -l user=deploy
sudo sudoreplay 000001

sudoreplay -l muestra las sesiones con sus identificadores y no imprime nada si log_output nunca se aplicó a ese usuario. Coste: cada byte que atraviesa el terminal se almacena en /var/log/sudo-io, por lo que una sesión verbosa ocupa mucho espacio. La segunda línea de sudoers impide que una reproducción vuelva a registrarse. El coste real son los secretos, porque un registro de E/S conserva todo lo que se escribió y se mostró, incluida una contraseña introducida en un indicador dentro de la sesión. Por tanto, necesita la misma protección que un almacén de contraseñas. La cobertura también es limitada. Registra los comandos ejecutados mediante sudo. Alguien que inicia sesión y trabaja siempre con su propia cuenta no se registra en absoluto.

Hooks de shell y cómo se omiten exactamente

La receta que circula para "registrar cada comando" es un hook de PROMPT_COMMAND colocado en /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 ejecuta PROMPT_COMMAND antes de mostrar cada prompt, por lo que la línea llega a syslog a medida que se escribe en lugar de al salir, y logger escribe a través del daemon de registro del sistema, por lo que los permisos de archivo del usuario nunca intervienen. Abra una nueva shell de inicio de sesión y verifique con sudo tail -f /var/log/syslog, o journalctl -t cmdlog -f en una imagen sin rsyslog.

Luego deja de funcionar, de cinco maneras que puede reproducir en un minuto.

  • Las shells no interactivas nunca muestran un prompt. ssh you@server 'id' ejecuta el comando y retorna, y no se registra nada, porque PROMPT_COMMAND nunca se evaluó.
  • Es una variable. unset PROMPT_COMMAND la deshabilita por el resto de la sesión y no requiere privilegios.
  • El archivo es leído por shells de inicio de sesión. bash --noprofile --norc nunca carga /etc/profile.d/ en absoluto.
  • Es específico de bash. zsh, sh, python3 -c 'import os; os.system("id")' y :!id dentro de vim ejecutan programas que ningún hook de prompt de bash verá jamás.
  • Registra la línea tal como se escribió, por lo que un alias o una función aún ocultan el comando que realmente se ejecutó.

Utilice un hook de shell como una conveniencia. Responde a "¿qué ejecuté el martes pasado?" para usuarios cooperativos. No permita que una lista de verificación lo llame un control.

El subsistema de auditoría del kernel registra cada execve

El subsistema de auditoría de Linux, gestionado por el demonio auditd, es la única capa que un usuario no puede eludir, ya que el registro se genera dentro del kernel en el momento en que se ejecuta la llamada al sistema. Si un proceso ejecuta un programa, se produce un evento. El shell, el lenguaje y la presencia de una terminal no influyen.

sudo apt update && sudo apt install -y auditd audispd-plugins
sudo systemctl enable --now auditd
sudo auditctl -s

auditctl -s muestra el estado del demonio. enabled 1 con un pid distinto de cero significa que está en ejecución, y lost 0 indica que aún no se han descartado registros. Recuerde ese contador lost, volverá a aparecer más adelante.

auid es el campo que hace que la auditoría valga la pena. PAM establece un uid de inicio de sesión cuando comienza una sesión, y el kernel lo mantiene en cada proceso hijo a partir de ese momento. Compruebe el suyo:

cat /proc/self/loginuid

Una sesión SSH interactiva muestra su uid, porque /etc/pam.d/sshd incluye pam_loginuid.so. Un valor de 4294967295 significa que el loginuid nunca se estableció, lo cual es normal para un proceso iniciado por un demonio del sistema durante el arranque. Lo importante es que sudo -i no lo cambia: un shell root abierto por alice sigue manteniendo el auid 1000, por lo que cada comando ejecutado en él es atribuible a alice. Esa es exactamente la brecha que deja abierta sudo. Cambiar un loginuid una vez establecido requiere CAP_AUDIT_CONTROL, que los usuarios normales no tienen, y sudo auditctl --loginuid-immutable lo bloquea incluso para root hasta el próximo reinicio.

Compruebe que /etc/pam.d/sshd, /etc/pam.d/login y /etc/pam.d/cron incluyan cada uno pam_loginuid.so, o los eventos llegarán sin nadie asociado a ellos. Es la misma lista de archivos que se modifica al endurecer el acceso SSH en un VPS, así que realice ambas tareas a la vez.

Un conjunto de reglas inicial para auditd

Las reglas residen en /etc/audit/rules.d/*.rules. augenrules las concatena en orden alfabético en una única lista; el orden determina el comportamiento, ya que el kernel se detiene en la primera regla que coincide. Lea lo que ya existe antes de añadir nada, puesto que un -D en un archivo posterior elimina todo lo cargado anteriormente.

ls /etc/audit/rules.d/
cat /etc/audit/rules.d/audit.rules

A continuación, escriba /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 auditconfig

Cárguelo y confirme:

sudo augenrules --load
sudo auditctl -l

auditctl -l imprimiendo sus reglas de vuelta significa que están activas. No rules significa que la carga falló, y journalctl -u auditd -n 20 indica el archivo y la línea que el analizador rechazó. Las versiones antiguas del espacio de usuario de audit no entienden la palabra clave unset. Si el cargador se queja de ese campo, escriba -F auid!=4294967295 en su lugar, que es el mismo valor expresado de forma explícita.

Ahora lea los eventos:

sudo ausearch -k exec -ts recent -i | tail -40
sudo ausearch -ul 1000 -ts today -i
sudo aureport -k --summary -i

-i convierte los uid y los números de syscall en nombres, y en la práctica no es opcional. -ts recent cubre los últimos diez minutos. Cada ejecución llega como un grupo de registros: un registro SYSCALL que contiene el uid, auid, estado de salida y clave, un registro EXECVE con la lista completa de argumentos, además de registros CWD y PATH para el contexto.

Un límite honesto, porque suele confundir a los usuarios. audit registra syscalls, y un comando interno (builtin) de shell no realiza ninguna syscall por sí mismo. cd /root no ejecuta ningún programa. echo evil >> /etc/passwd escrito en un prompt de bash tampoco ejecuta ningún programa, porque tanto el echo como la redirección ocurren dentro del proceso de shell que ya está en ejecución. Por lo tanto, las reglas execve ven los programas y las reglas -w ven las escrituras. Ninguna de las dos es suficiente por sí sola.

Finalmente, bloquee la configuración:

## /etc/audit/rules.d/99-finalize.rules
-e 2

-e 2 hace que el conjunto de reglas sea inmutable hasta el próximo reinicio. Tras cargarlo, auditctl -s informa enabled 2, y cualquier intento de añadir o eliminar una regla fallará con Operation not permitted, incluso para root. Añada este archivo al final y espere tener que reiniciar cada vez que desee cambiar una regla. Ese intercambio es el objetivo: un conjunto de reglas que cualquiera pueda desactivar silenciosamente no sirve como evidencia.

Un registro de auditoría que nadie lee es un artefacto de cumplimiento

El modo de fallo de auditd no es que omita información. Es que registra tanto que nadie lo consulta, por lo que el registro existe para cumplir con una lista de verificación en lugar de responder a una pregunta.

Haga los cálculos en su propio equipo antes de ajustar nada:

sudo aureport -k --summary -i
sudo du -sh /var/log/audit

Un solo sudo apt upgrade ejecuta miles de procesos de corta duración, y cada uno de ellos lleva su auid, por lo que una actualización de paquetes puede generar más datos que una semana de actividad humana. Por eso las supresiones anteriores mencionan a dpkg y sus auxiliares. Aplique supresiones por ejecutable, nunca por usuario: una exclusión para /usr/bin/dpkg es un agujero que se puede describir en una frase, mientras que una exclusión para una cuenta es un agujero con la forma exacta de lo que intentaba detectar.

La clave -k en cada regla es lo que permite que el registro sea consultable un mes después. ausearch -k sudoers es una pregunta con una respuesta. ausearch sin filtros es un muro de texto que le condiciona a dejar de leer. Si su recolector requiere JSON en lugar del formato nativo, laurel es un plugin de auditd que reescribe cada evento como un objeto JSON con los argumentos decodificados. Se registra en /etc/audit/plugins.d/ como cualquier otro plugin, y auditd detecta los cambios en los plugins al ejecutar sudo pkill -HUP auditd.

Costes reales de auditd

Cada llamada al sistema que coincide con una regla se convierte en un registro que el kernel formatea y entrega al espacio de usuario. El coste recae en dos puntos, y ambos son medibles en su propia carga de trabajo en lugar de ser estimaciones basadas en cifras publicadas por terceros.

  • CPU y latencia. Una máquina que realiza forks constantemente, como un host de compilación o un runner de CI, genera un registro por cada exec. Cuando el backlog del kernel se llena, --backlog_wait_time hace que el kernel pause el proceso que generó el evento hasta que haya espacio disponible; por tanto, audit se manifiesta como compilaciones lentas en lugar de como un porcentaje de CPU. Supervise backlog y lost en sudo auditctl -s bajo carga real. Un valor creciente en lost significa que se han descartado registros, y un log con lagunas silenciosas es peor que no tener log, porque usted seguirá confiando en él.
  • Disco. Lea /etc/audit/auditd.conf y decida deliberadamente qué sucede cuando el disco se llena, ya que los valores que vienen por defecto son solo opiniones. max_log_file, num_logs y max_log_file_action controlan la rotación. space_left_action, admin_space_left_action y disk_full_action controlan la emergencia, y algunas de las acciones disponibles, entre ellas halt y single, detienen la máquina antes que perder un registro.

La línea -f en /etc/audit/rules.d/audit.rules representa esa misma decisión a nivel de kernel: -f 1 informa de un fallo de auditoría a syslog, y -f 2 provoca un kernel panic. Elija 2 solo si realmente prefiere perder el servidor antes que perder un registro. En un VPS que ejecuta servicios críticos, opte por la rotación y traslade el problema de almacenamiento fuera del equipo.

Enviar los registros fuera del servidor, casi en tiempo real

Esta es la parte que los informes de incidentes siguen demostrando. Los registros que permanecen en el servidor comprometido pueden ser editados por quienquiera que lo haya vulnerado. El usuario root puede reescribir /var/log/auth.log, borrar /var/log/audit/audit.log y detener el daemon. -e 2 evita que se descarguen las reglas. No hace nada respecto a rm. Cada capa superior solo genera pruebas si primero sale una copia de la máquina.

El transporte propio de audit es el plugin audisp-remote de audispd-plugins. Actívelo en /etc/audit/plugins.d/au-remote.conf:

active = yes
direction = out
path = /usr/sbin/audisp-remote
type = always
format = string

Compruebe path contra command -v audisp-remote antes de recargar, porque una ruta incorrecta no produce nada excepto una línea en el journal. Establezca remote_server y port en /etc/audit/audisp-remote.conf, y en el colector establezca tcp_listen_port = 60 en su propio auditd.conf. Recargue con sudo pkill -HUP auditd. En muchas imágenes se rechaza systemctl restart auditd, porque el archivo de unidad establece RefuseManualStop=yes, por lo que la señal es la ruta fiable.

La otra opción coloca a audit en el flujo de syslog que usted ya reenvía. /etc/audit/plugins.d/syslog.conf se distribuye con active = no. Ajústelo a yes, recargue, y los eventos de audit se unirán a las líneas de sudo y al resto. Luego reenvíe todo con rsyslog sobre TLS (transport layer security), lo cual requiere el paquete 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")

Los ajustes de la cola son la parte interesante. action.resumeRetryCount="-1" reintenta indefinidamente, y la cola asistida por disco con queue.saveOnShutdown="on" retiene los registros mientras el colector no está accesible, para luego enviarlos cuando vuelve a estar disponible. Sin ambos, un reinicio del colector deja un hueco en sus pruebas y nada que le indique que el hueco existe. Aplique los cambios con sudo systemctl restart rsyslog, luego confirme que los registros realmente llegan al colector antes de confiar en ellos.

Queda un cabo suelto: el colector debe ser una máquina a la que las personas auditadas no puedan acceder. Si el mismo grupo de administradores tiene acceso root en el servidor de registros, usted ha copiado el archivo, no lo ha protegido. Use credenciales separadas, claves separadas y, idealmente, una cuenta de proveedor distinta. Este es el mismo razonamiento que hace que una forma centralizada de gestionar muchos servidores Linux valga la pena construirla antes de necesitarla, y es la diferencia entre una primera hora útil y una inútil cuando está trabajando en un VPS comprometido.

Compruebe que un usuario normal no puede sobrescribir el registro

Pruebe la afirmación en lugar de asumirla. Desde una cuenta ordinaria, sin sudo:

echo test >> /var/log/auth.log
cat /var/log/audit/audit.log
auditctl -D
id -nG

Espere, en orden: Permission denied, porque auth.log es propiedad de syslog con grupo adm y modo 640; Permission denied de nuevo, porque el registro de auditoría tiene modo 600 y es propiedad de root; un error que rechaza la ejecución, porque cambiar las reglas de auditoría requiere CAP_AUDIT_CONTROL; y una lista de grupos que no contiene ni adm ni systemd-journal.

Esa última comprobación es en la que la gente falla. La pertenencia a adm otorga acceso de lectura a /var/log/auth.log, y la pertenencia a systemd-journal otorga acceso de lectura a todo el journal. Ninguna otorga acceso de escritura, por lo que ninguna permite la manipulación. Ambas permiten a una persona leer cada línea de autenticación en el equipo, lo cual es una decisión que debe tomarse a propósito en lugar de copiar una línea usermod -aG de la respuesta de un foro.

Finalmente, confirme las dos cosas que deben sobrevivir a un reinicio:

sudo auditctl -s
systemctl is-enabled auditd

enabled 2 significa que el conjunto de reglas está bloqueado hasta el próximo arranque. enabled del segundo comando significa que auditd se inicia de nuevo después de ese arranque. Un conjunto de reglas que solo dura hasta la próxima actualización del kernel tampoco es un registro de auditoría.

FAQ

¿Cómo puedo ver todos los comandos que ejecutó un usuario concreto?

Obtenga su uid con id -u alice y, después, busque en el registro de auditoría por el uid de inicio de sesión: sudo ausearch -ul 1000 -ts today -i. Añada -k exec para limitar la búsqueda a la regla execve. El uid de inicio de sesión se establece al iniciar sesión y se conserva durante su y sudo -i, por lo que esto también detecta los comandos ejecutados dentro de un shell root que ese usuario abrió. Sólo funciona con los comandos ejecutados después de cargar las reglas, porque audit no conserva un historial de los eventos que no estaba configurado para registrar. sudo aureport -k --summary -i muestra los recuentos por regla si primero quiere conocer la distribución de los datos.

¿Puede un usuario eliminar su historial de bash para ocultar lo que ejecutó?

Sí, y no necesita privilegios. ~/.bash_history pertenece a ese usuario y tiene el modo 600, por lo que puede editarlo, truncarlo o eliminarlo. También puede impedir que se escriba mediante unset HISTFILE, detener la grabación durante la sesión con set +o history u ocultar comandos concretos escribiéndolos con un espacio inicial cuando HISTCONTROL=ignorespace está configurado. Bash escribe el archivo cuando termina el shell, por lo que una sesión terminada con kill -9 $$ no registra nada. Una conexión interrumpida no basta para ocultar la actividad, porque bash guarda el historial cuando SIGHUP provoca la desconexión. Trate el historial del shell como una indicación, nunca como una prueba.

¿Registra sudo lo que ocurre dentro de sudo -i?

No. sudo registra el comando que se le pidió ejecutar, por lo que sudo -i genera una línea para el shell y nada más. Todos los comandos escritos en ese shell root son invisibles para sudo, porque sudo ya no interviene. sudo su -, sudo bash y cualquier programa permitido que ofrezca una salida al shell se comportan igual. Dos medidas cierran esta brecha: reglas de audit sobre execve, que registran cada programa con el uid de inicio de sesión original asociado, y reglas de sudoers que no proporcionan un shell desde el principio.

¿Ralentizará auditd mi servidor?

Depende por completo de cuántos procesos inicie la carga de trabajo, así que mídalo en lugar de confiar en una cifra. Un servidor que principalmente responde a solicitudes ejecuta muy pocos procesos y no notará el impacto. Un host de compilación o un ejecutor de CI ejecuta procesos constantemente y puede notar una ralentización considerable, porque cuando se llena la cola de auditoría del kernel, el proceso que generó el evento queda pausado hasta que haya espacio. Ejecute sudo auditctl -s con carga real y supervise backlog y lost. Cualquier lost superior a cero significa que se descartaron registros. Es el peor resultado, porque el registro ahora contiene brechas invisibles.

¿Dónde deben almacenarse los registros de auditoría?

En otra máquina, con un retraso medido en segundos. Cualquiera que obtenga root en el host auditado puede eliminar /var/log/audit/audit.log y modificar /var/log/auth.log, por lo que las copias locales sólo permiten responder preguntas sobre incidentes que nadie intentó ocultar. Reenvíe los registros con el plugin audisp-remote a un auditd central, o habilite el plugin de syslog de audit y reenvíe todo el flujo de syslog con rsyslog mediante TLS. Asigne al recolector sus propias credenciales y asegúrese de que las cuentas auditadas no tengan acceso a él.

¿Te resultó útil este artículo?