auditd: auditoria de eventos do sistema Linux

auditd é o subsistema de auditoria do kernel Linux, registra chamadas de sistema, acesso a arquivos, uso de sudo, mudanças de autenticação e execução de binários privilegiados. Em um ambiente de produção, é a diferença entre "algo aconteceu" e "aqui está exatamente o que, quando, quem e como".

Instalação e configuração inicial

Instalar auditd e configurar parâmetros básicos:

bash
# Instalar auditd:
sudo apt update && sudo apt install auditd audispd-plugins

# Iniciar e habilitar:
sudo systemctl enable auditd
sudo systemctl start auditd

# Verificar status:
sudo auditctl -s
# Saída: enabled=1 significa que auditoria está ativa

# Configuração principal: /etc/audit/auditd.conf
# Parâmetros importantes:
sudo tee /etc/audit/auditd.conf << 'EOF'
log_file = /var/log/audit/audit.log
log_format = ENRICHED         # incluir nomes de usuário (não apenas UIDs)
log_group = adm
priority_boost = 4
flush = INCREMENTAL_ASYNC
freq = 50
max_log_file = 50             # MB por arquivo de log
num_logs = 10                 # manter 10 arquivos rotacionados
max_log_file_action = ROTATE
space_left = 500              # MB livres antes de alertar
space_left_action = SYSLOG
admin_space_left = 100
admin_space_left_action = SUSPEND  # parar auditoria se disco cheio
disk_full_action = SUSPEND
disk_error_action = SUSPEND
EOF

sudo systemctl restart auditd

Regras de auditoria com auditctl

Definir o que monitorar: arquivos, syscalls e comandos:

bash
# Adicionar regras temporárias (perdidas no reboot):
# Para persistir: adicionar em /etc/audit/rules.d/audit.rules

# Monitorar acesso a arquivos sensíveis:
sudo auditctl -w /etc/passwd -p rwxa -k identity
sudo auditctl -w /etc/shadow -p rwxa -k identity
sudo auditctl -w /etc/sudoers -p rwxa -k sudo-config
sudo auditctl -w /etc/ssh/sshd_config -p rwxa -k ssh-config

# Monitorar diretório inteiro:
sudo auditctl -w /etc/cron.d -p rwa -k cron-config
sudo auditctl -w /root -p rwxa -k root-access

# Monitorar execução de comandos críticos:
sudo auditctl -a always,exit -F arch=b64 -S execve   -F path=/usr/bin/passwd -k passwd-use

# Monitorar escalonamento de privilégios:
sudo auditctl -a always,exit -F arch=b64 -S setuid -k priv-escalation

# Criar arquivo de regras persistentes:
sudo tee /etc/audit/rules.d/hardening.rules << 'EOF'
# Remover todas as regras ao carregar:
-D

# Aumentar buffer para evitar perda de eventos:
-b 8192

# Identidade e autenticação:
-w /etc/passwd -p rwxa -k identity
-w /etc/shadow -p rwxa -k identity
-w /etc/group -p rwxa -k identity
-w /etc/sudoers -p rwa -k sudo-config
-w /etc/sudoers.d -p rwa -k sudo-config

# SSH:
-w /etc/ssh/sshd_config -p rwxa -k ssh-config
-w /root/.ssh -p rwxa -k root-ssh

# Sudo e comandos privilegiados:
-a always,exit -F arch=b64 -S execve -F euid=0 -k root-commands

# Imutabilizar regras (impede alteração em runtime até reboot):
-e 2
EOF

sudo augenrules --load

Consultar e interpretar logs

Usar ausearch e aureport para extrair informações:

bash
# ausearch: buscar eventos por critério:

# Todos os eventos de uma chave de auditoria:
sudo ausearch -k identity --interpret | head -50

# Eventos de sudo nas últimas 24h:
sudo ausearch -k sudo-config -ts today --interpret

# Eventos de login (falhas):
sudo ausearch -m USER_AUTH -sv no --interpret | head -30

# Buscar por usuário:
sudo ausearch -ua root --interpret -ts recent

# Buscar por arquivo específico:
sudo ausearch -f /etc/passwd --interpret

# aureport: relatórios resumidos:

# Relatório de autenticações:
sudo aureport -au --summary

# Relatório de eventos de falha:
sudo aureport --failed --summary

# Relatório de execuções de comandos:
sudo aureport -x --summary | head -20

# Relatório de logins:
sudo aureport -l --summary

# Relatório completo do dia:
sudo aureport -ts today

Detectar eventos suspeitos

Queries para identificar atividade maliciosa:

bash
# Detectar criação de arquivos SUID (possível escalonamento de privilégio):
sudo ausearch -m SYSCALL -sv yes --interpret |   grep -E "SUID|chmod.*4[0-9]{3}" | head -20

# Detectar execução como root por usuário normal (sudo abuse):
sudo ausearch -m USER_CMD --interpret | grep "res=success" | head -30

# Detectar mudanças em authorized_keys (backdoor SSH):
sudo ausearch -f authorized_keys --interpret

# Detectar adição de usuário ao sistema:
sudo ausearch -k identity --interpret | grep "useradd|adduser"

# Detectar acesso a /etc/shadow (tentativa de dump de hashes):
sudo ausearch -k identity -f /etc/shadow --interpret

# Script de alerta para eventos críticos (rodar via cron):
cat << 'SCRIPT' > /usr/local/bin/audit-check.sh
#!/bin/bash
EVENTOS=$(ausearch -ts "$(date -d '1 hour ago' '+%m/%d/%Y %H:%M:%S')"           -k identity -k sudo-config -k ssh-config           -sv yes --interpret 2>/dev/null | wc -l)
if [ "$EVENTOS" -gt 0 ]; then
  echo "⚠️ $EVENTOS eventos de auditoria críticos na última hora" |     mail -s "Auditoria Linux: alerta" admin@seudominio.com.br
fi
SCRIPT
chmod +x /usr/local/bin/audit-check.sh
echo "0 * * * * root /usr/local/bin/audit-check.sh" >> /etc/cron.d/audit-check

Enviar logs para sistema centralizado

Exportar logs do auditd para Loki, Elasticsearch ou syslog remoto:

bash
# Opção 1: audispd → syslog → Loki (via Promtail):
# /etc/audit/plugins.d/syslog.conf:
sudo sed -i 's/active = no/active = yes/' /etc/audit/plugins.d/syslog.conf
sudo systemctl restart auditd

# Opção 2: audispd → audisp-remote (envio direto para servidor de logs):
# /etc/audisp/plugins.d/au-remote.conf:
sudo tee /etc/audisp/plugins.d/au-remote.conf << 'EOF'
active = yes
direction = out
path = /sbin/audisp-remote
type = always
format = string
EOF

# /etc/audisp/audisp-remote.conf:
sudo tee /etc/audisp/audisp-remote.conf << 'EOF'
remote_server = 10.0.0.5       # servidor de logs centralizado
port = 60
EOF

# Opção 3: Vector (moderno, com transformações):
# /etc/vector/vector.toml:
# [sources.auditd]
# type = "file"
# include = ["/var/log/audit/audit.log"]
# [sinks.loki]
# type = "loki"
# endpoint = "http://loki:3100"
# labels = { host = "{{ host }}", job = "auditd" }

Não quer configurar manualmente?

Implante o VPS Linux em menos de 5 minutos com a Runstack. Infraestrutura da OPEN Datacenter, com servidores em São Paulo.

Perguntas frequentes

syslog: logs de nível de aplicação, o que processos decidem registrar. auditd: auditoria de nível de kernel, captura chamadas de sistema independente de o processo querer ou não registrar. Um processo malicioso pode desabilitar seu próprio logging, mas não pode contornar o auditd (que funciona no kernel). Para segurança real: auditd captura o que o syslog não captura, acesso a arquivos, syscalls, mudanças de identidade.

O impacto varia com o número de regras e volume de eventos. Regras típicas de hardening (monitorar /etc, SSH, sudo) têm impacto negligenciável (< 1% CPU). Regras amplas como monitorar todas as execuções de binários (-S execve sem filtro) podem gerar dezenas de milhares de eventos por segundo em servidores busy, ajuste com filtros por usuário (-F uid!=0 para ignorar root, ou -F auid=1000 para usuário específico). Comece com regras específicas e expanda conforme necessário.

A diretiva -e 2 imutabiliza as regras de auditoria em runtime, ninguém pode adicionar, remover ou modificar as regras sem reboot. Sem -e 2: um atacante com acesso root poderia desabilitar o auditd ou remover regras específicas antes de executar ações maliciosas, apagando as evidências. Com -e 2: auditctl falha com "Operation not permitted" ao tentar modificar. Necessário reiniciar o servidor para alterar as regras, use com consciência.

Opções por custo/complexidade: (1) Grafana Loki + Promtail: envia logs via syslog, custo baixo, análise com LogQL; (2) Elastic Stack (ELK): filebeat lê audit.log com módulo específico, Elasticsearch indexa, Kibana visualiza; (3) Wazuh: plataforma SIEM open-source com regras pré-prontas para auditd, alertas e dashboards; (4) Falco: detecta comportamento anômalo em runtime em containers e hosts. Para VPS simples: Loki + Grafana é suficiente e leve.

Para rastrear execução do processo Node.js: sudo auditctl -a always,exit -F arch=b64 -S execve -F path=/usr/bin/node -k nodejs-exec. Para rastrear acesso a arquivos sensíveis pelo Node.js: sudo auditctl -w /etc/ssl/private -p r -F uid=$(id -u nodejs) -k nodejs-ssl-access. Mais prático: instrumentar a aplicação com OpenTelemetry + traces, e usar auditd apenas para auditoria de segurança do SO, cada ferramenta tem seu nível de abstração.