# Como saber se seu VPS foi invadido e se precisa reconstruir

Um roteiro de triagem que separa invasão de conta de comprometimento de root, com o que cada checagem deve mostrar, onde ela engana e o ponto em que limpar deixa de ser opção.

> Reconstrua se houver binário de sistema alterado (rpm -Va ou dpkg --verify), persistência no root (chave em /root/.ssh, cron, systemd, ld.so.preload) ou log de autenticação apagado. Se todos os achados têm dono de uma conta de site, limpe a conta, troque credenciais e corrija a porta de entrada.

João Rizzon · 2026-11-13 · Servidores

---

## O que esta triagem decide

A pergunta útil não é "fui invadido", e sim **em que nível**. Um invasor que executa código como o usuário do site (via plugin vulnerável, senha de FTP vazada, upload sem validação) consegue rodar minerador, mandar spam e plantar arquivo em `/tmp`. Ainda assim, ele não alterou binário de sistema nem módulo de kernel. Um invasor com root consegue tudo isso e também consegue mentir para as ferramentas que você usa para investigar.

A decisão sai daí:

- **Comprometimento de usuário ou aplicação**: limpa a conta, troca credenciais, corrige a porta de entrada. O servidor continua confiável.
- **Comprometimento de root**: o servidor deixa de ser confiável. Reinstala o sistema operacional e restaura **dados**, não o sistema.

A documentação do cPanel sobre [como determinar o estado do sistema](https://docs.cpanel.net/knowledge-base/security/determine-your-system-status/) segue essa mesma linha: quando há indício de acesso de root, a recomendação é reinstalar o sistema e restaurar a partir de backup anterior ao incidente, com apoio de um administrador qualificado, em vez de tentar limpar a máquina no lugar.

Cada checagem abaixo traz pré-requisito, resultado esperado e o erro comum que leva à conclusão errada. Os comandos são exemplos com ferramentas padrão de Linux; adapte caminhos à sua distribuição.

## O que preparar e o que não fazer antes do primeiro comando

Você precisa de acesso root por SSH e, de preferência, de um segundo canal (console do provedor, KVM ou modo rescue). Se o root estiver comprometido, o SSH pode estar adulterado, e o console fora de banda é a única leitura que não passa por ele.

Regras antes do primeiro comando:

- **Não reinicie ainda.** Processo em memória, conexão aberta e binário apagado mas em execução somem no reboot. São justamente as evidências que separam usuário de root.
- **Não apague nada** antes de copiar. Para cada arquivo suspeito, registre primeiro a saída de `stat` (mtime, ctime, atime) e o hash (`sha256sum`), e copie esse registro para fora da máquina. Só depois mova o arquivo para fora do docroot e aplique `chmod 000`: mover e trocar permissão atualizam o ctime, que é o carimbo usado na Checagem 3 para datar o ataque.
- **Copie os logs para fora da máquina** (`/var/log/secure` ou `/var/log/auth.log`, `/var/log/messages`, logs do Exim e do Apache). Invasor com root apaga log.
- **Anote o horário** de cada achado. A linha do tempo é o que diz qual backup é limpo.

Erro comum: rodar um scanner automático primeiro e tratar "nada encontrado" como atestado. Scanner procura assinatura conhecida. Ausência de assinatura não prova ausência de invasor.

## Como identificar o processo que consome CPU sem tráfego

**Pré-requisito**: saber a carga normal da máquina. Sem linha de base, load 6 pode ser terça-feira comum.

```
ps -eo pid,user,pcpu,etime,cmd --sort=-pcpu | head -15
ls -l /proc/<PID>/exe
cat /proc/<PID>/cmdline | tr '\0' ' '
```

**Resultado esperado em máquina saudável**: o topo da lista é `httpd`, `php-fpm`, `mysqld`, `lsphp` ou backup em andamento, e o consumo acompanha os acessos no log do servidor web.

**Indício de comprometimento**: processo com nome genérico (`kworker` rodando como usuário comum, `[kthreadd]` com dono que não é root, nome aleatório), `exe` apontando para `/tmp`, `/var/tmp` ou `/dev/shm`, ou com sufixo `(deleted)`. Binário apagado em execução é técnica clássica para dificultar análise.

**Como ler o nível**: se o dono do processo é o usuário de uma conta ou `nobody`, o ponto de partida é aplicação. Se o processo roda como root sem motivo, ou se `top` mostra CPU alta e nenhum processo justifica o consumo, trate como suspeita de root: ferramenta de listagem que esconde processo é sinal de binário ou biblioteca adulterada.

Erro comum: matar o processo e seguir. Ele volta pelo cron ou pelo arquivo que o lançou. Antes do `kill`, registre `exe`, `cmdline`, `cwd` (`ls -l /proc/<PID>/cwd`) e o usuário.

## Como verificar se o servidor está enviando spam sem autorização

**Pré-requisito**: saber qual MTA a máquina usa. Em cPanel é Exim.

```
exim -bpc
exim -bp | head -40
ss -tnp state established '( dport = :25 )'
```

**Resultado esperado**: fila pequena e estável, e conexões de saída na porta 25 vindas do processo do MTA.

**Indício de comprometimento**: fila crescendo rápido, remetentes que não existem no servidor, ou conexão na porta 25 aberta por processo que não é o MTA (um `perl` ou `php` falando SMTP direto com servidor remoto). O segundo caso é o mais grave, porque contorna o MTA, o limite de envio por domínio e o log do Exim.

**Como ler o nível**: spam via script PHP de uma conta, ou via senha de caixa de e-mail vazada (envio autenticado, visível no log com o usuário), é problema de aplicação ou credencial. Spam saindo sem rastro em log nenhum, de processo que você não consegue ver, puxa para root.

Erro comum: limpar a fila e considerar resolvido. A fila é sintoma. Descubra a origem pelo cabeçalho da mensagem (`exim -Mvh <id>`), pelo usuário autenticado ou pelo script que chamou o envio.

## Quais arquivos em /tmp, /var/tmp e /dev/shm são suspeitos

**Pré-requisito**: saber se `/tmp` está montado com `noexec` (`findmnt /tmp`). Se estiver, binário ali só roda se alguém chamar o interpretador explicitamente.

```
ls -la /tmp /var/tmp /dev/shm
find /tmp /var/tmp /dev/shm -type f -perm -u+x -ls
find /tmp /var/tmp /dev/shm -name '.*' -ls
```

**Resultado esperado**: sessões PHP, sockets do MySQL ou do PHP-FPM, arquivos temporários de upload e cache, com donos coerentes.

**Indício de comprometimento**: ELF executável, diretório oculto com nome de espaço ou ponto (`. `, `...`), script com `wget` ou `curl` para IP remoto, arquivo de configuração de minerador.

**Como ler o nível**: o dono do arquivo é a pista principal. Arquivo de usuário de conta aponta para aplicação. Arquivo de root em diretório temporário, sem processo legítimo que o explique, é sinal forte de root.

Erro comum: usar `mtime` para datar o ataque. Quem tem acesso ao arquivo pode ajustar o horário com `touch`. Prefira `ctime` (`stat`). O `touch` também o altera, mas sempre grava a hora atual do relógio: ele não consegue retroagir o ctime para uma data arbitrária. Um ctime recente ao lado de um mtime antigo é, inclusive, indício de manipulação. Cruze com o log de acesso. A ressalva: o ctime resiste a invasor de nível usuário, não a root. Com root, dá para forjá-lo mudando o relógio do sistema antes de tocar o arquivo ou editando o inode com `debugfs` no dispositivo. Se houver qualquer indício de root, date o ataque pelos logs copiados para fora da máquina e pela comparação entre backups, não pelos carimbos do sistema de arquivos.

## Integridade de pacotes: por que é o sinal mais forte de root

É a checagem que mais pesa na decisão, e também a que mais engana.

```
rpm -Va 2>/dev/null | grep -v ' c ' 
rpm -qf /usr/bin/ssh /usr/sbin/sshd /bin/ps /bin/ls
```

Em Debian e Ubuntu, `dpkg --verify` cumpre papel parecido.

**Pré-requisito**: entender a saída. Cada caractere marca um desvio: `S` tamanho, `5` checksum, `M` permissão, `T` data de modificação. O `c` indica arquivo de configuração, que muda por edição legítima e por isso foi filtrado acima. O filtro tem custo: `/etc/pam.d/*`, `/etc/ssh/sshd_config` e `/etc/security/*` também são marcados como `c` e são alvo comum de backdoor de autenticação (linha `pam_exec` ou módulo extra no PAM, `AuthorizedKeysCommand` apontando para script, `PermitRootLogin` reaberto). Revise esses arquivos à parte: `rpm -V pam openssh-server` mostra quais mudaram, sem filtro, e o conteúdo de cada um precisa ser lido linha a linha.

**Resultado esperado**: alterações em arquivos de configuração e alguns `T` sem `5`. Mudança só de data costuma ser cópia ou atualização, não troca de conteúdo.

**Indício de root**: `5` em binário de sistema (`ssh`, `sshd`, `ps`, `ls`, `netstat`, `top`, bibliotecas em `/lib64`). Também conta arquivo em diretório de sistema que `rpm -qf` responde como "não pertence a nenhum pacote", sobretudo biblioteca carregada pelo `sshd`. Variações do rootkit Ebury, por exemplo, foram associadas a bibliotecas adulteradas ligadas ao SSH.

Erro comum: confiar no resultado limpo. Se o invasor tem root, ele pode ter alterado o próprio `rpm` ou o banco de pacotes. Um `rpm -Va` sem desvios reduz a suspeita, mas não zera. Rodar a partir de mídia de rescue resolve só metade: `rpm --root /mnt/sysimage -Va` com o binário do rescue ainda compara contra o rpmdb gravado no disco montado, que o invasor pode ter reescrito. Para leitura confiável, a referência tem de vir de fora: baixe dos repositórios oficiais os pacotes nas mesmas versões instaladas (`openssh-clients`, `openssh-server`, `procps-ng`, `coreutils`, `glibc`, `pam`; a versão exata sai de `rpm -qf` no binário suspeito, por exemplo `rpm --root /mnt/sysimage -qf /usr/sbin/sshd`, e serve só para escolher o pacote, não como prova de integridade), confira a assinatura com `rpm -K`, extraia com `rpm2cpio pacote.rpm | cpio -idm` e compare o `sha256sum` de cada binário com o arquivo correspondente no disco montado. Em Debian e Ubuntu, baixe os `.deb` com `apt-get download` (a cadeia de assinatura do repositório valida o pacote) e rode `debsums --root=/mnt pacote.deb`, que usa os checksums de dentro do `.deb` e não os de `/var/lib/dpkg/info` do disco suspeito.

## Acessos e persistência: onde o invasor se mantém no servidor

**Pré-requisito**: logs copiados para fora da máquina e a lista de IPs legítimos de quem administra.

```
last -a | head -30
grep 'Accepted' /var/log/secure | tail -50
ls -la /var/spool/cron/ /etc/cron.d/
cat /root/.ssh/authorized_keys
systemctl list-unit-files --state=enabled
```

**Resultado esperado**: logins de root vindos de IPs conhecidos, chaves que você reconhece, crons e serviços que você ou o painel criaram.

**Indício de comprometimento**: chave desconhecida em `authorized_keys` de root, login de root de origem estranha, cron de root baixando script remoto, serviço systemd com nome plausível apontando para binário fora de `/usr`, entradas em `/etc/ld.so.preload`. Qualquer persistência no contexto de root encerra a triagem: o veredito é reconstruir.

Erro comum: concluir que "não houve login de root" porque o log está limpo. Log de autenticação com buraco de horário, arquivo zerado ou rotação fora do padrão é, por si, indício.

## Quando limpar a conta e quando reconstruir o servidor

| Achado | Nível provável | Ação |
|---|---|---||
| Processo, arquivo ou cron com dono de uma conta de site | Usuário ou aplicação | Limpar a conta, trocar senhas, corrigir a vulnerabilidade |
| Spam autenticado com caixa de e-mail | Credencial | Trocar a senha, revisar encaminhamentos e filtros |
| Spam por script PHP de uma conta | Aplicação | Remover o script, achar a porta de entrada |
| `5` em binário de sistema no `rpm -Va` | Root | Reconstruir |
| Chave desconhecida em `/root/.ssh` ou cron de root suspeito | Root | Reconstruir |
| CPU consumida sem processo visível, conexões que `ss` não mostra | Root (ferramentas adulteradas) | Reconstruir |
| Logs de autenticação apagados ou com lacunas | Root provável | Reconstruir |

Reconstruir, na prática: suba um servidor novo com sistema limpo e atualizado, restaure só **dados** (arquivos de site, bancos, e-mails) a partir de backup anterior ao primeiro indício da linha do tempo, e troque todas as credenciais que passaram pela máquina antiga, inclusive chaves SSH, senhas de banco e tokens de API guardados em arquivos de configuração. Não restaure `/etc`, binários nem crons da máquina comprometida. Revise o código restaurado antes de colocá-lo no ar, porque backup anterior ao incidente pode conter a mesma vulnerabilidade que permitiu a entrada.

Se a triagem parou no nível de usuário, a reconstrução é exagero, e a recomendação honesta é não fazê-la: limpe a conta afetada, aplique a correção e monitore as mesmas checagens por alguns dias. O custo de reconstruir sem necessidade é alto e não traz segurança adicional.

Há um caso cinzento: indício de usuário mais algum detalhe que você não consegue explicar no nível de sistema. Aí o critério é a confiança. Se você não consegue afirmar que o root está intacto, trate como comprometido. Limpar uma máquina com root comprometido deixa um servidor que parece limpo justamente porque o invasor controla o que você vê.

