FERRAMENTAS LINUX: Debian Linux: Guia Prático para Identificar e Corrigir Vulnerabilidades Críticas no Kernel

Aprenda a verificar, corrigir e mitigar vulnerabilidades críticas no kernel Linux do Debian (CVE-2025-22069, CVE-2025-68251, CVE-2025-68768, CVE-2025-71289). Guia completo com comandos, script de automação e medidas alternativas para administradores de sistemas.

O que aconteceu?

Em [data da publicação original], a equipe de segurança do Debian divulgou o DSA-6355-1, alertando sobre múltiplas vulnerabilidades no kernel Linux que afetam sistemas Debian.

Quatro CVEs foram identificadas, com impactos que vão desde negação de serviço (DoS) até escalonamento de privilégio e vazamento de informações.

Resumo das vulnerabilidades

A versão corrigida para a distribuição estável (trixie) é a 6.12.94-1.

Como verificar se você está vulnerável

Antes de aplicar qualquer correção, é fundamental saber se seu sistema está afetado. Execute os comandos abaixo no terminal do seu Debian.

1. Verifique a versão do kernel em execução

uname -r

Compare a saída com a versão corrigida (6.12.94-1 ou superior). Se sua versão for anterior, você está potencialmente vulnerável.

2. Verifique se os pacotes do kernel estão atualizados

apt list --installed | grep -E "^linux-image-|^linux-headers-"

3. Consulte o status de segurança do kernel no Debian

# Verifica se há atualizações de segurança pendentes
apt list --upgradable | grep linux

# Consulta diretamente o rastreador de segurança (online)
curl -s https://security-tracker.debian.org/tracker/linux | grep -A5 "CVE-2025"

4. Script completo de verificação

Salve o script abaixo como check-kernel-vuln.sh e execute com bash check-kernel-vuln.sh:

#!/bin/bash
# check-kernel-vuln.sh - Verifica se o sistema Debian está vulnerável às CVEs do DSA-6355-1
# Uso: bash check-kernel-vuln.sh

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo "=== Verificação de Vulnerabilidades do Kernel (DSA-6355-1) ==="
echo ""

# Versão atual do kernel
KERNEL_VERSION=$(uname -r)
echo "Kernel em execução: $KERNEL_VERSION"

# Versão corrigida (para Debian trixie)
FIXED_VERSION="6.12.94-1"

# Função para comparar versões (simples)
version_lt() {
    [ "$(printf '%s\n' "$1" "$2" | sort -V | head -n1)" = "$1" ] && [ "$1" != "$2" ]
}

if version_lt "$KERNEL_VERSION" "$FIXED_VERSION"; then
    echo -e "${RED}⚠ ATENÇÃO: Kernel anterior à versão corrigida ($FIXED_VERSION)${NC}"
    echo -e "${RED}→ Sistema VULNERÁVEL às CVEs do DSA-6355-1${NC}"
    VULNERABLE=1
else
    echo -e "${GREEN}✓ Kernel atualizado para versão $FIXED_VERSION ou superior${NC}"
    echo -e "${GREEN}→ Sistema NÃO VULNERÁVEL (pelo menos para estas CVEs)${NC}"
    VULNERABLE=0
fi

echo ""

# Verifica pacotes linux instalados
echo "Pacotes do kernel instalados:"
dpkg -l | grep -E "linux-image|linux-headers" | awk '{print $2 " " $3}'

echo ""

# Verifica se há atualizações pendentes
echo "Verificando atualizações de segurança pendentes..."
UPDATES=$(apt list --upgradable 2>/dev/null | grep -c linux)
if [ "$UPDATES" -gt 0 ]; then
    echo -e "${YELLOW}→ $UPDATES atualizações relacionadas ao kernel disponíveis${NC}"
else
    echo -e "${GREEN}→ Nenhuma atualização do kernel pendente${NC}"
fi

echo ""
echo "=== Recomendações ==="
if [ $VULNERABLE -eq 1 ]; then
    echo -e "${RED}1. Execute imediatamente: sudo apt update && sudo apt upgrade -y${NC}"
    echo -e "${RED}2. Reinicie o sistema: sudo reboot${NC}"
    echo -e "${YELLOW}3. Se não puder reiniciar agora, veja as medidas alternativas abaixo${NC}"
else
    echo -e "${GREEN}✓ Sistema protegido. Continue monitorando atualizações de segurança.${NC}"
fi

Script de automação para aplicar a correção

Este script atualiza automaticamente o kernel e reinicia o sistema de forma segura. Ideal para servidores onde você deseja agendar a atualização.

#!/bin/bash
# auto-kernel-update.sh - Aplica automaticamente a correção do DSA-6355-1
# Uso: sudo bash auto-kernel-update.sh [--no-reboot]

set -e

LOG_FILE="/var/log/kernel-update-$(date +%Y%m%d-%H%M%S).log"
exec > >(tee -a "$LOG_FILE") 2>&1

echo "=== Iniciando atualização do kernel (DSA-6355-1) ==="
echo "Data: $(date)"
echo ""

# Verifica se é root
if [ "$EUID" -ne 0 ]; then
    echo "ERRO: Este script precisa ser executado como root (use sudo)."
    exit 1
fi

# Faz backup do kernel atual
echo "→ Criando backup do kernel atual..."
dpkg -l | grep linux-image | awk '{print $2 " " $3}' > /root/kernel-backup-$(date +%Y%m%d).txt

# Atualiza a lista de pacotes
echo "→ Atualizando lista de pacotes..."
apt update

# Atualiza apenas pacotes relacionados ao kernel (opção mais segura)
echo "→ Instalando atualizações do kernel..."
apt install --only-upgrade linux-image-* linux-headers-* -y

# Verifica se a atualização foi bem-sucedida
NEW_KERNEL=$(uname -r)
echo "→ Novo kernel instalado (será ativado após reinicialização): $NEW_KERNEL"

# Verifica se o novo kernel é a versão corrigida
FIXED_VERSION="6.12.94-1"
if [ "$(printf '%s\n' "$NEW_KERNEL" "$FIXED_VERSION" | sort -V | head -n1)" = "$FIXED_VERSION" ] || [ "$NEW_KERNEL" = "$FIXED_VERSION" ]; then
    echo "✓ Kernel atualizado para versão corrigida."
else
    echo "⚠ ATENÇÃO: O kernel instalado pode não ser a versão corrigida. Verifique manualmente."
fi

# Pergunta sobre reinicialização
if [ "$1" != "--no-reboot" ]; then
    echo ""
    read -p "→ Reiniciar o sistema agora? (s/N) " -n 1 -r
    echo ""
    if [[ $REPLY =~ ^[Ss]$ ]]; then
        echo "→ Reiniciando em 10 segundos..."
        sleep 10
        reboot
    else
        echo "→ Reinicialização adiada. O novo kernel será ativado na próxima reinicialização."
    fi
else
    echo "→ Reinicialização automática desativada (--no-reboot)."
    echo "→ Lembre-se de reiniciar o sistema para ativar o novo kernel."
fi

echo ""
echo "=== Atualização concluída ==="
echo "Log salvo em: $LOG_FILE"

Como usar:

# Baixe o script e torne-o executável
wget -O auto-kernel-update.sh https://seu-servidor/scripts/auto-kernel-update.sh
chmod +x auto-kernel-update.sh

# Execute com sudo
sudo ./auto-kernel-update.sh

# Para evitar reinicialização automática:
sudo ./auto-kernel-update.sh --no-reboot

📗 Recomendação de Leitura

Segurança em servidores Linux: Ataque e Defesa (anúncio) -> https://link.amazon/B0hlDkNqk

Se você prefere estudar em português e quer aprender a "pensar como um hacker" para se antecipar a invasões, essa é a pedida! O livro ensina a usar as ferramentas prediletas dos invasores (como Nmap e Netcat) a seu favor, blindando seus sistemas.

Eu ganho uma comissão quando você faz uma compra.

Mitigação alternativa caso não possa atualizar agora

Se você não pode reiniciar o servidor imediatamente ou precisa de uma camada extra de proteção, estas medidas podem reduzir o risco de exploração.

1. Restringir acesso local e a usuários não confiáveis

A maioria dessas vulnerabilidades requer acesso local ao sistema. Limitar quem pode acessar o servidor é a primeira linha de defesa:

# Revise usuários com shell ativo
cat /etc/passwd | grep -E ":/bin/bash|:/bin/sh"

# Remova ou desative usuários desnecessários
usermod -s /usr/sbin/nologin usuario_nao_utilizado

2. Mitigar DoS via rede (CVE-2025-68768)

A vulnerabilidade de deadlock no subsistema de rede pode ser parcialmente mitigada com regras de firewall que limitam a fragmentação de pacotes:

# Limita a taxa de pacotes fragmentados (mitigação parcial para DoS)
iptables -A INPUT -f -m limit --limit 100/s --limit-burst 200 -j ACCEPT
iptables -A INPUT -f -j DROP

# Limita conexões novas por IP (prevenção geral contra DoS)
iptables -A INPUT -p tcp -m connlimit --connlimit-above 100 -j REJECT --reject-with tcp-reset

# Salva as regras (Debian)
iptables-save > /etc/iptables/rules.v4

Para sistemas com nftables (mais recente):

nft add rule inet filter input ip frag-off != 0 limit rate 100/second accept
nft add rule inet filter input ip frag-off != 0 drop

3. Hardening com sysctl

Aplicar configurações de hardening do kernel pode reduzir a superfície de ataque:

# Adicione ao /etc/sysctl.conf ou /etc/sysctl.d/99-hardening.conf

# Proteção contra estouro de pilha
kernel.randomize_va_space = 2

# Restringe acesso a /proc/kcore
kernel.kptr_restrict = 2

# Protege contra ataques de ponteiro de função
kernel.unprivileged_bpf_disabled = 1

# Aplica as configurações
sysctl -p /etc/sysctl.d/99-hardening.conf

4. AppArmor para restringir processos

Se você usa sistemas de arquivos EROFS ou NTFS, o AppArmor pode restringir o acesso a esses módulos:

# Instala o AppArmor se não estiver presente
apt install apparmor apparmor-utils -y

# Ativa o perfil para montagem de sistemas de arquivos
aa-enforce /usr/bin/mount

5. Desabilitar módulos de kernel não utilizados

# Lista módulos carregados
lsmod | grep -E "erofs|ntfs"

# Bloqueia o carregamento do módulo (adicione ao /etc/modprobe.d/blacklist.conf)
echo "blacklist erofs" >> /etc/modprobe.d/blacklist.conf
echo "blacklist ntfs3" >> /etc/modprobe.d/blacklist.conf

# Atualiza o initramfs
update-initramfs -u

Conclusão

Vulnerabilidades no kernel são uma realidade constante em qualquer sistema Linux. O DSA-6355-1 é mais um lembrete de que manter o sistema atualizado é a prática mais importante para a segurança.

Lembre-se: atualizações de kernel são críticas, mas exigem planejamento — especialmente em ambientes de produção. Agende janelas de manutenção, teste em ambientes de homologação e mantenha backups.

Páginas

domingo, 21 de junho de 2026

Debian Linux: Guia Prático para Identificar e Corrigir Vulnerabilidades Críticas no Kernel