Hardening de Servidores Linux: Guia Completo de Segurança

O hardening de servidores Linux é um processo essencial para reduzir a superfície de ataque e fortalecer a postura de segurança da infraestrutura. Este guia aborda técnicas práticas e comprovadas para implementar controles de segurança efetivos.

Princípios Fundamentais

Defesa em Profundidade

O hardening efetivo implementa múltiplas camadas de segurança:

Segurança física: Controle de acesso ao hardware
Segurança de rede: Firewalls e segmentação
Segurança do sistema: Configurações e controles
Segurança de aplicação: Validação e sanitização
Segurança de dados: Criptografia e backup

Princípio do Menor Privilégio

Conceda apenas as permissões mínimas necessárias:

Usuários com privilégios limitados
Serviços executando com contas específicas
Acesso baseado em funções (RBAC)
Revisão regular de permissões

Configuração Inicial do Sistema

Atualização e Patches

Mantenha o sistema sempre atualizado:

# Ubuntu/Debian
sudo apt update && sudo apt upgrade -y
sudo apt autoremove -y

# CentOS/RHEL
sudo yum update -y
sudo yum autoremove -y

# Configurar atualizações automáticas
sudo apt install unattended-upgrades
sudo dpkg-reconfigure unattended-upgrades

Configuração de Usuários

Desabilitar conta root:

# Bloquear login direto do root
sudo passwd -l root

# Configurar sudo para usuário administrativo
sudo usermod -aG sudo username

Política de senhas:

# Instalar libpam-pwquality
sudo apt install libpam-pwquality

# Configurar em /etc/pam.d/common-password
password requisite pam_pwquality.so retry=3 minlen=12 difok=3 ucredit=-1 lcredit=-1 dcredit=-1 ocredit=-1

Configuração SSH

Hardening do SSH:

# Editar /etc/ssh/sshd_config
sudo nano /etc/ssh/sshd_config

# Configurações recomendadas:
Port 2222                          # Mudar porta padrão
Protocol 2                         # Usar apenas protocolo 2
PermitRootLogin no                 # Desabilitar login root
PasswordAuthentication no          # Usar apenas chaves
PubkeyAuthentication yes           # Habilitar autenticação por chave
MaxAuthTries 3                     # Limitar tentativas
ClientAliveInterval 300            # Timeout de sessão
ClientAliveCountMax 2              # Máximo de timeouts
AllowUsers username                # Permitir apenas usuários específicos

Configurar autenticação por chave:

# Gerar par de chaves
ssh-keygen -t rsa -b 4096 -C "user@domain.com"

# Copiar chave pública para servidor
ssh-copy-id -i ~/.ssh/id_rsa.pub user@server

# Definir permissões corretas
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Configuração de Firewall

UFW (Uncomplicated Firewall)

# Habilitar UFW
sudo ufw enable

# Política padrão
sudo ufw default deny incoming
sudo ufw default allow outgoing

# Permitir SSH na nova porta
sudo ufw allow 2222/tcp

# Permitir serviços específicos
sudo ufw allow 80/tcp    # HTTP
sudo ufw allow 443/tcp   # HTTPS

# Verificar status
sudo ufw status verbose

iptables Avançado

# Script básico de iptables
#!/bin/bash

# Limpar regras existentes
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X

# Política padrão
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT

# Permitir loopback
iptables -A INPUT -i lo -j ACCEPT

# Permitir conexões estabelecidas
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Permitir SSH
iptables -A INPUT -p tcp --dport 2222 -j ACCEPT

# Permitir HTTP/HTTPS
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# Proteção contra ataques
iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL ALL -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL FIN,URG,PSH -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP

# Salvar regras
iptables-save > /etc/iptables/rules.v4

Monitoramento e Auditoria

Configurar auditd

# Instalar auditd
sudo apt install auditd audispd-plugins

# Configurar regras em /etc/audit/rules.d/audit.rules
# Monitorar arquivos críticos
-w /etc/passwd -p wa -k passwd_changes
-w /etc/group -p wa -k group_changes
-w /etc/shadow -p wa -k shadow_changes
-w /etc/sudoers -p wa -k sudoers_changes

# Monitorar comandos privilegiados
-a always,exit -F arch=b64 -S execve -F euid=0 -k root_commands
-a always,exit -F arch=b32 -S execve -F euid=0 -k root_commands

# Monitorar acessos de rede
-a always,exit -F arch=b64 -S socket -F a0=2 -k network_connect
-a always,exit -F arch=b32 -S socket -F a0=2 -k network_connect

# Reiniciar serviço
sudo systemctl restart auditd

Configurar rsyslog

# Configurar logging centralizado em /etc/rsyslog.conf
# Enviar logs para servidor central
*.* @@logserver.domain.com:514

# Configurar rotação de logs
sudo nano /etc/logrotate.d/rsyslog

/var/log/syslog {
    daily
    missingok
    rotate 52
    compress
    delaycompress
    notifempty
    create 640 syslog adm
    postrotate
        systemctl reload rsyslog
    endscript
}

Controles de Acesso

SELinux/AppArmor

Configurar AppArmor (Ubuntu):

# Verificar status
sudo aa-status

# Instalar perfis adicionais
sudo apt install apparmor-profiles apparmor-utils

# Colocar perfil em modo enforce
sudo aa-enforce /etc/apparmor.d/usr.bin.firefox

# Criar perfil personalizado
sudo aa-genprof /path/to/application

Configurar SELinux (CentOS/RHEL):

# Verificar status
sestatus

# Configurar modo enforcing
sudo setenforce 1
sudo sed -i 's/SELINUX=.*/SELINUX=enforcing/' /etc/selinux/config

# Gerenciar contextos
sudo setsebool -P httpd_can_network_connect 1
sudo restorecon -R /var/www/html

Controle de Recursos

Configurar limits:

# Editar /etc/security/limits.conf
* soft nofile 65536
* hard nofile 65536
* soft nproc 32768
* hard nproc 32768

# Para usuários específicos
username soft nofile 1024
username hard nofile 2048

Configurar systemd limits:

# Criar arquivo de configuração
sudo mkdir -p /etc/systemd/system/service.service.d/
sudo nano /etc/systemd/system/service.service.d/limits.conf

[Service]
LimitNOFILE=65536
LimitNPROC=32768

Criptografia e Proteção de Dados

Criptografia de Disco

LUKS (Linux Unified Key Setup):

# Criptografar partição
sudo cryptsetup luksFormat /dev/sdb1

# Abrir partição criptografada
sudo cryptsetup luksOpen /dev/sdb1 encrypted_disk

# Formatar e montar
sudo mkfs.ext4 /dev/mapper/encrypted_disk
sudo mount /dev/mapper/encrypted_disk /mnt/encrypted

# Configurar montagem automática em /etc/crypttab
encrypted_disk /dev/sdb1 none luks

Backup Seguro

# Script de backup com criptografia
#!/bin/bash

BACKUP_DIR="/backup"
SOURCE_DIR="/data"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="backup_${DATE}.tar.gz"

# Criar backup comprimido
tar -czf ${BACKUP_DIR}/${BACKUP_FILE} ${SOURCE_DIR}

# Criptografar backup
gpg --cipher-algo AES256 --compress-algo 1 --s2k-mode 3 \
    --s2k-digest-algo SHA512 --s2k-count 65536 --symmetric \
    --output ${BACKUP_DIR}/${BACKUP_FILE}.gpg ${BACKUP_DIR}/${BACKUP_FILE}

# Remover arquivo não criptografado
rm ${BACKUP_DIR}/${BACKUP_FILE}

# Verificar integridade
gpg --decrypt ${BACKUP_DIR}/${BACKUP_FILE}.gpg | tar -tzf - > /dev/null

Detecção de Intrusão

Configurar AIDE

# Instalar AIDE
sudo apt install aide

# Inicializar base de dados
sudo aideinit

# Mover base de dados
sudo mv /var/lib/aide/aide.db.new /var/lib/aide/aide.db

# Executar verificação
sudo aide --check

# Automatizar verificações
echo "0 2 * * * root /usr/bin/aide --check" | sudo tee -a /etc/crontab

Configurar fail2ban

# Instalar fail2ban
sudo apt install fail2ban

# Configurar em /etc/fail2ban/jail.local
[DEFAULT]
bantime = 3600
findtime = 600
maxretry = 3
backend = systemd

[sshd]
enabled = true
port = 2222
filter = sshd
logpath = /var/log/auth.log
maxretry = 3

[apache-auth]
enabled = true
port = http,https
filter = apache-auth
logpath = /var/log/apache2/error.log
maxretry = 6

# Reiniciar serviço
sudo systemctl restart fail2ban

Monitoramento Contínuo

Scripts de Verificação

#!/bin/bash
# Script de verificação de segurança

echo "=== Verificação de Segurança $(date) ==="

# Verificar usuários com UID 0
echo "Usuários com UID 0:"
awk -F: '$3 == 0 {print $1}' /etc/passwd

# Verificar arquivos SUID
echo "Arquivos SUID suspeitos:"
find / -type f -perm -4000 2>/dev/null | grep -v -E '^/(bin|usr/bin|sbin|usr/sbin)/'

# Verificar conexões de rede
echo "Conexões de rede ativas:"
netstat -tulpn | grep LISTEN

# Verificar processos em execução
echo "Processos suspeitos:"
ps aux | grep -E '(nc|netcat|ncat)' | grep -v grep

# Verificar logs de autenticação
echo "Tentativas de login falhadas (últimas 10):"
grep "Failed password" /var/log/auth.log | tail -10

# Verificar integridade do sistema
echo "Verificação AIDE:"
aide --check | head -20

Alertas Automatizados

# Script de alerta por email
#!/bin/bash

ALERT_EMAIL="admin@domain.com"
HOSTNAME=$(hostname)

# Verificar carga do sistema
LOAD=$(uptime | awk '{print $10}' | sed 's/,//')
if (( $(echo "$LOAD > 5.0" | bc -l) )); then
    echo "Alta carga no servidor $HOSTNAME: $LOAD" | \
    mail -s "Alerta: Alta carga - $HOSTNAME" $ALERT_EMAIL
fi

# Verificar espaço em disco
DISK_USAGE=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')
if [ $DISK_USAGE -gt 90 ]; then
    echo "Espaço em disco baixo no servidor $HOSTNAME: ${DISK_USAGE}%" | \
    mail -s "Alerta: Disco cheio - $HOSTNAME" $ALERT_EMAIL
fi

# Verificar tentativas de login
FAILED_LOGINS=$(grep "Failed password" /var/log/auth.log | grep "$(date '+%b %d')" | wc -l)
if [ $FAILED_LOGINS -gt 10 ]; then
    echo "Múltiplas tentativas de login falhadas: $FAILED_LOGINS" | \
    mail -s "Alerta: Tentativas de invasão - $HOSTNAME" $ALERT_EMAIL
fi

Checklist de Hardening

Configuração Básica

[ ] Sistema atualizado
[ ] Usuário root desabilitado
[ ] SSH configurado com chaves
[ ] Firewall configurado
[ ] Serviços desnecessários removidos

Monitoramento

[ ] auditd configurado
[ ] Logs centralizados
[ ] AIDE instalado
[ ] fail2ban configurado
[ ] Alertas automatizados

Controles de Acesso

[ ] SELinux/AppArmor habilitado
[ ] Limites de recursos configurados
[ ] Políticas de senha implementadas
[ ] Sudo configurado adequadamente

Proteção de Dados

[ ] Criptografia de disco
[ ] Backup seguro
[ ] Rotação de logs
[ ] Retenção de dados definida

Conclusão

O hardening de servidores Linux é um processo contínuo que requer atenção constante e atualizações regulares. A implementação dessas práticas reduzirá significativamente a superfície de ataque e melhorará a postura de segurança da infraestrutura.

Próximos Passos

Implemente monitoramento de integridade de arquivos
Configure detecção de anomalias comportamentais
Desenvolva playbooks de resposta a incidentes
Considere implementação de zero trust architecture