# Impedir que um site leia arquivos de outra conta no Apache

Como funciona a checagem de dono do symlink no EasyApache 4, como validar com um teste de leitura cruzada em laboratório e o que quebra em deploys com release compartilhado.

> a camada que impede isso no Apache com cPanel é a proteção contra race condition de symlink do EasyApache 4, que compara o dono do link simbólico com o dono do arquivo alvo no momento da abertura e falha quando os UIDs diferem, bloqueando leitura cruzada entre homedirs.

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

---

## O que a proteção de symlink realmente impede

Em hospedagem compartilhada, Apache abre arquivos como um usuário (via `mod_ruid2`, `mpm_itk`, `suexec` ou o UID atribuído no VirtualHost). O problema clássico não é o PHP ler `/etc/passwd`: é o PHP de uma conta invadida criar um link simbólico dentro do próprio `public_html` apontando para `/home/outro/public_html/wp-config.php` e pedir que o Apache sirva esse caminho. Se o processo que abre o arquivo tiver permissão de leitura no alvo, o conteúdo sai pelo HTTP. Credencial de banco, chave de API, salt do WordPress.

A variante de corrida é pior e dá nome à feature. O atacante substitui um arquivo comum por um symlink entre o momento em que o Apache resolve o caminho e o momento em que ele abre o descritor. Checagem feita em userland com `lstat()` antes do `open()` perde essa janela por construção, porque são duas chamadas distintas sobre um caminho que muda no meio.

A proteção de race condition de symlink documentada pela cPanel para o EasyApache 4 ataca isso na camada de abertura do arquivo: ao abrir, o dono do link e o dono do alvo são comparados, e a operação falha quando não coincidem. A referência é a página oficial [EasyApache 4 Symlink Race Condition Protection](https://docs.cpanel.net/ea4/apache/symlink-race-condition-protection/).

## Onde a opção vive no EasyApache 4

A proteção não é uma diretiva solta que você joga no `.htaccess`. Ela depende do binário do Apache construído com o patch de symlink race condition e de a opção estar marcada na configuração global do Apache. O caminho no WHM é Home >> Service Configuration >> Apache Configuration >> Global Configuration, na opção rotulada Symlink Protection. Marcar a caixa e salvar dispara a reconstrução da configuração a partir dos templates EA4, que grava a diretiva no arquivo gerado `/etc/apache2/conf/httpd.conf` (o diretório `/etc/apache2/conf.d/` é de includes, não é onde o arquivo principal é gerado): edição manual em `/etc/apache2/conf/httpd.conf` é sobrescrita na próxima reconstrução. Rótulo e local do item mudaram entre versões do cPanel e entre perfis EA4, então confira a página oficial citada acima se a opção não aparecer onde descrito.

Pontos que valem conferir no seu servidor antes de mexer:

- Qual pacote de Apache está instalado (`ea-apache24`) e qual módulo de troca de identidade está ativo. Sem UID por conta, a checagem de dono do symlink perde sentido, porque todo mundo abre como o mesmo usuário.
- Se há CloudLinux no host. O CloudLinux tem mecanismo próprio de proteção de links simbólicos no kernel; empilhar duas camadas com semânticas diferentes rende erro difícil de diagnosticar.
- Se existe NFS ou bind mount em `/home`. Dono reportado em filesystem de rede pode não ser o que você espera.

```bash
# inventário mínimo antes de alterar qualquer coisa
rpm -q ea-apache24
httpd -V | head -n 5
httpd -M 2>/dev/null | grep -Ei 'ruid|itk|suexec|userdir'
stat -c '%U %G %a %n' /home/labalvo/public_html
```

## Roteiro de laboratório para provar a leitura cruzada

Faça isto em servidor de teste, com duas contas criadas para o exercício. Os nomes abaixo são exemplo fictício: `labatk` (a conta que simula o site invadido) e `labalvo` (a vítima).

### 1. Preparar o alvo

```bash
# como root
echo "DB_PASSWORD=exemplo-de-laboratorio" > /home/labalvo/public_html/wp-config.php
chown labalvo:labalvo /home/labalvo/public_html/wp-config.php
chmod 644 /home/labalvo/public_html/wp-config.php
```

Permissão 644 é o caso realista: o arquivo precisa ser legível pelo processo que roda o site dono dele, e em muitos ambientes acaba legível por outros UIDs também.

### 2. Plantar o symlink e o leitor

```bash
# como labatk
cd ~/public_html
ln -s /home/labalvo/public_html/wp-config.php leak.txt
printf '<?php readfile("leak.txt");' > leak.php
```

### 3. Testar os dois caminhos

```bash
curl -s -o /dev/null -w '%{http_code}\n' http://labatk.exemplo/leak.txt   # Apache servindo o symlink
curl -s http://labatk.exemplo/leak.php | head -c 200                     # PHP abrindo o symlink
```

São vetores diferentes e precisam ser medidos separados. O primeiro depende do Apache e de `Options FollowSymLinks`. O segundo depende do processo PHP e, quando existe, do `open_basedir`. Ligue a proteção, reinicie o Apache e repita os dois comandos. Anote código HTTP, corpo retornado e a linha correspondente em `/usr/local/apache/logs/error_log`.

| Vetor | Sem proteção | Com proteção de symlink | Observação |
|---|---|---|---||
| `GET /leak.txt` (arquivo estático) | conteúdo do alvo | falha na abertura, erro no log | também cai com `Options -FollowSymLinks`, mas isso quebra muito site |
| `readfile()` em PHP | conteúdo do alvo | falha na abertura | `open_basedir` já barra, se estiver configurado por vhost |
| `include` de vendor compartilhado por symlink | funciona | falha se o alvo tiver outro dono | principal fonte de falso positivo |
| Symlink dentro do mesmo homedir | funciona | funciona | dono do link e do alvo coincidem |

## O custo: uma verificação de propriedade a cada abertura de arquivo

O custo é estrutural, não depende de carga: cada abertura de arquivo paga uma verificação extra de propriedade. A partir daí entra hipótese, e é bom deixar explícito: espero que o custo cresça com a profundidade do caminho, porque a resolução percorre componente a componente, mas a página oficial citada não descreve a verificação nesse nível de detalhe e eu não instrumentei o kernel para confirmar. Trate como modelo mental, não como fato. Quanto mais arquivos por requisição, mais vezes isso acontece. Uma página que serve cem arquivos estáticos de `/home/conta/public_html/wp-content/themes/x/assets/dist/` paga a verificação em cada um deles, e, se a hipótese acima valer, também em cada nível da árvore.

A Napoleon não mediu esse overhead em laboratório próprio, e não vou publicar número que não medi. O que dá para raciocinar sem medição, e tratar como hipótese até você medir no seu hardware, é o perfil do custo e como reduzi-lo:

- Árvore rasa deve custar menos que árvore profunda. Reduzir níveis de diretório em assets tende a ajudar mais do que parece.
- Estático atrás de cache (ou servido por outra camada) sai da conta inteira.
- Keep-alive e HTTP/2 não mudam o número de aberturas de arquivo, só o custo de conexão.

Se você precisa do número no seu hardware, meça antes e depois com a mesma árvore de arquivos, mesmo cache de página desligado e `ab`/`wrk` no mesmo host, comparando tempo por requisição em um conjunto de arquivos estáticos profundos. É um teste de meia hora e vale mais que qualquer estimativa de terceiro.

## O que quebra na prática

Quase todo incidente pós-ativação cai em um destes quatro casos, e todos têm a mesma assinatura: o alvo do symlink tem dono diferente do link.

- **Deploy estilo Capistrano com releases fora do homedir.** `current -> /opt/releases/2024-11-03` com `/opt` pertencendo a root. Corrija movendo releases para dentro do homedir da conta e com o mesmo UID.
- **Vendor ou node_modules compartilhado entre contas.** Um diretório único linkado por vários sites economiza disco e vira o primeiro a falhar. A saída é duplicar por conta ou empacotar no release.
- **Uploads apontando para `/tmp` ou para um volume comum.** `/tmp` é root e sticky. Use um diretório dentro do homedir e ajuste a configuração da aplicação.
- **Symlink criado por root durante manutenção.** `ln -s` feito como root dentro do `public_html` do cliente deixa o link com dono root e o alvo com dono da conta. `chown -h conta:conta link` resolve, e o `-h` é obrigatório para agir no link e não no alvo.

Para varrer o servidor antes de ligar a proteção e saber o tamanho do problema:

```bash
# lista symlinks cujo dono do link difere do dono do alvo
# separador | evita quebra em caminhos com espaco; alvo relativo e resolvido
# a partir do diretorio do proprio link, nao do cwd
find /home -maxdepth 6 -type l -printf '%u|%l|%p\n' 2>/dev/null | \
  while IFS='|' read -r owner target link; do
    case "$target" in
      /*) abs="$target" ;;
      *)  abs="$(dirname "$link")/$target" ;;
    esac
    if ! tgt_owner=$(stat -Lc '%U' "$abs" 2>/dev/null); then
      echo "ALVO INACESSIVEL $link -> $target"
      continue
    fi
    [ "$owner" != "$tgt_owner" ] && echo "$link -> $abs ($owner != $tgt_owner)"
  done
```

`stat -L` segue o link e devolve o dono do alvo final, inclusive em cadeia de symlinks. Alvo inacessivel aparece na saida em vez de sumir: pode ser link quebrado, pode ser diretorio pai sem permissao de travessia para root em filesystem de rede, e os dois casos merecem olhada. Nome de arquivo com quebra de linha ainda engana esse laço; se desconfiar disso, troque por `find ... -print0` com `-printf` equivalente e processe em Perl ou Python.

Rode isso em horário de baixa carga. `find` em `/home` com muitos inodes consome I/O.

## Verificação, perfil EA4 e reversão

Trate a ativação como mudança de build, não como toggle cosmético. O caminho seguro:

### 1. Salvar o perfil atual

No WHM, em EasyApache 4, exporte o perfil em uso para JSON antes de qualquer alteração. Esse arquivo é o seu ponto de retorno, inclusive para a lista exata de pacotes e versões de PHP instaladas.

### 2. Aplicar em janela controlada

Recompilar ou instalar pacote do Apache reinicia o serviço. Valide a sintaxe antes do restart:

```bash
httpd -t
/scripts/restartsrv_httpd
tail -n 100 /usr/local/apache/logs/error_log
```

### 3. Verificar que a proteção está ativa

Use o próprio laboratório da seção anterior como teste de aceitação, e rode os dois comandos, não um só.

```bash
curl -s -o /dev/null -w '%{http_code}\n' http://labatk.exemplo/leak.txt
curl -s http://labatk.exemplo/leak.php | head -c 200
```

O veredito sobre a proteção de symlink está em `leak.txt`: é o Apache abrindo o arquivo. Se ele continuar devolvendo o conteúdo da outra conta, a proteção não está em vigor, independentemente do que o painel mostre. `leak.php` não prova nada sozinho nos dois sentidos: pode falhar por `open_basedir` ou por política do pool PHP-FPM com a proteção desligada, e pode passar se o PHP rodar fora do caminho de abertura protegido. Registre o resultado dos dois, mas conclua pelo primeiro.

### 4. Reverter

Reversão tem duas partes: desmarcar Symlink Protection em WHM >> Service Configuration >> Apache Configuration >> Global Configuration e, se houve troca de pacotes, restaurar o perfil EA4 exportado no passo 1. Reinicie o Apache e repita o teste de laboratório, agora esperando o comportamento antigo. Documente qual dos dois passos você executou, porque desligar a opção sem restaurar o perfil deixa o servidor em estado intermediário difícil de reproduzir depois.

## O que essa camada não resolve

Proteção de symlink impede leitura cruzada por link simbólico. Ela não impede:

- Leitura cruzada por caminho direto quando as permissões do alvo são frouxas e o processo compartilha UID ou grupo. Confira `chmod 750` em `public_html` e dono correto.
- Hard link, que não é symlink e tem semântica própria de propriedade.
- Acesso via serviços que rodam como root ou como usuário único, incluindo scripts de backup mal escritos.
- Vazamento pela aplicação: LFI, backup `.sql` dentro de `public_html`, `.git` exposto.

O conjunto mínimo que faz sentido manter junto é: UID por conta no Apache, `open_basedir` por vhost, permissões restritas em `public_html`, proteção de symlink e um teste de aceitação versionado que você roda depois de cada atualização do EasyApache 4. O teste é a parte que as pessoas esquecem, e é a única que avisa quando uma recompilação derrubou a proteção sem avisar ninguém.

