# Permission denied no WordPress: é o dono, não o 777

Como descobrir o UID efetivo do PHP na sua conta, comparar com o dono real dos arquivos e corrigir a divergência sem abrir permissão para o servidor inteiro.

> "permission denied" ao atualizar plugin quase nunca é modo de arquivo: é divergência entre o UID sob o qual o PHP executa e o dono do que está gravado. Descubra o UID com posix_geteuid(), compare com stat -c '%U:%G %a' e corrija com chown, não com 777.

João Rizzon · 2026-10-12 · WordPress

---

## O sintoma engana: "permission denied" raramente é só permissão

Você clica em atualizar um plugin e o WordPress responde que não conseguiu criar o diretório, ou pede credenciais de FTP do nada. O reflexo é olhar o modo do arquivo, ver `755`, achar pouco, e subir para `777`. A atualização passa. Duas semanas depois volta a falhar, agora em outra pasta.

O que mudou não foi o modo, foi o **dono**. Em um mesmo `wp-content` convivem arquivos criados por canais diferentes: o que você enviou por SFTP pertence ao usuário da conta; o que o PHP gravou pertence ao usuário sob o qual o PHP executou naquela requisição. Se esses dois não forem o mesmo UID, metade da árvore fica fora do alcance de escrita do processo que precisa escrever.

Permissão responde "o que o dono, o grupo e os outros podem fazer". Dono responde "quem é o dono". Subir para `777` só desloca a pergunta: agora qualquer processo do servidor escreve ali, e o arquivo que o PHP criar continua nascendo com o UID errado, perpetuando a divergência no próximo diretório.

## Sob qual usuário o PHP está rodando nesta conta

Antes de mexer em qualquer coisa, descubra o UID efetivo do processo PHP **no site em questão**. Não assuma pelo painel, nem pelo que vale em outro domínio do mesmo servidor.

Crie um arquivo temporário na raiz do site, por exemplo `whoami-php.php`:

```php
<?php
// Exige PHP 7.0+ (usa o operador ??) e a extensão posix carregada.
header('Content-Type: text/plain');

echo 'uid efetivo: ' . posix_geteuid() . "\n";
echo 'gid efetivo: ' . posix_getegid() . "\n";

$u = posix_getpwuid(posix_geteuid());
$g = posix_getgrgid(posix_getegid());
// ambas retornam false se o UID/GID nao existir em /etc/passwd ou /etc/group
echo 'usuario: ' . (is_array($u) ? $u['name'] : '?') . "\n";
echo 'grupo:   ' . (is_array($g) ? $g['name'] : '?') . "\n";

// dono do proprio arquivo, para comparar
echo 'dono deste .php (uid): ' . getmyuid() . "\n";
echo 'umask: ' . sprintf('%04o', umask()) . "\n";
```

Saída de **exemplo**, fictícia, apenas para leitura:

```
uid efetivo: 1037
gid efetivo: 1037
usuario: meusite
grupo:   meusite
dono deste .php (uid): 1037
umask: 0022
```

Se `posix_geteuid()` e `getmyuid()` baterem, o PHP executa como o dono do código e a escrita tende a funcionar sem abrir permissão para terceiros. Se divergirem, você achou a causa.

Apague o arquivo depois. Ele expõe o nome do usuário do sistema.

### Como descobrir o UID quando a extensão posix está desabilitada

`posix_*` pode estar desabilitada por `disable_functions`. Nesse caso use o que sobra:

```php
<?php
echo get_current_user() . "\n";          // dono do script, nao do processo
$f = tempnam(sys_get_temp_dir(), 'own');
echo fileowner($f) . "\n";               // uid que criou o arquivo
unlink($f);
```

`get_current_user()` devolve o dono do script, não o usuário efetivo. A criação do arquivo temporário é mais honesta: ela mostra qual UID o filesystem registra quando o PHP escreve.

### Identificar o usuário do PHP pelo shell, com SSH

```bash
ps -eo user,pid,etime,cmd | grep -E 'php-fpm|lsphp' | grep -v grep
```

Ignore o processo master (quase sempre root) e olhe os workers. Em servidores com suEXEC por conta, você verá um worker por usuário. A [documentação do LiteSpeed sobre suEXEC](https://docs.litespeedtech.com/lsws/suexec/) descreve esse modelo: cada processo externo PHP é iniciado sob o usuário configurado para o virtual host, em vez de rodar sob o usuário do servidor web.

## Compare com o dono real do que já foi gravado

Com o UID do PHP em mãos, leia o dono e o modo do que importa:

```bash
stat -c '%U:%G %a %n' wp-content wp-content/plugins wp-content/uploads wp-config.php
```

E para achar a divergência dentro de uma árvore grande:

```bash
# tudo em wp-content que NAO pertence ao usuario da conta
find wp-content ! -user meusite -printf '%u:%g %m %p\n' | head -50

# contagem por dono, para ver o tamanho do estrago
find wp-content -printf '%u\n' | sort | uniq -c | sort -rn
```

Saída de **exemplo**:

```
  18422 meusite
    613 nobody
     44 www-data
```

Três donos na mesma árvore é o retrato do problema. `nobody` e `www-data` são nomes clássicos de usuário do servidor web; aparecem quando o PHP gravou sem suEXEC, em algum momento da vida daquele site, ou quando um restore foi feito por um processo rodando como o servidor.

## O que o par dono/modo está dizendo em cada combinação

| Dono do arquivo | Usuário efetivo do PHP | Modo | Sintoma típico | Correção |
|---|---|---|---|---||
| `meusite` | `meusite` | `644`/`755` | nenhum, estado saudável | nada |
| `nobody` | `meusite` | `644` | "Could not create directory", pede FTP | `chown` para o usuário da conta |
| `meusite` | `nobody` | `644` | update falha, upload falha | ajustar suEXEC/pool, não o chmod |
| misto na mesma pasta | `meusite` | `755` | falha só em alguns plugins | `chown -R` na árvore inteira |
| `nobody` | `meusite` | `777` | "funciona", até o próximo diretório novo | `chown` e voltar para `755`/`644` |
| `root` | `meusite` | qualquer | escrita impossível, ninguém consegue corrigir sem root | `chown` como root |

A linha que mais aparece em site antigo é a quinta: alguém já aplicou `777` no passado, o site escreve, e o diagnóstico fica mascarado até o WordPress precisar criar um subdiretório novo que nasce com o dono errado.

## Por que o WordPress pede FTP mesmo com a pasta em 777

O instalador de plugins e temas não testa permissão lendo o modo. Ele cria um arquivo temporário no diretório de destino, verifica o dono desse arquivo e compara com o dono do arquivo PHP em execução. Se baterem, usa acesso direto ao filesystem. Se não baterem, assume que escrever direto é inseguro e cai para outro método, que normalmente significa pedir credenciais de FTP ou SSH na tela.

Isso explica o comportamento que parece irracional: a pasta está `777`, o PHP consegue escrever tecnicamente, e mesmo assim aparece o formulário de FTP. O critério não foi "posso escrever", foi "o dono é o mesmo".

Daí o antídoto errado que circula em fórum:

```php
// NAO use isso como solucao definitiva
define('FS_METHOD', 'direct');
```

Forçar `direct` em `wp-config.php` instrui o WordPress a escrever mesmo com dono divergente. Pode destravar a atualização. E produz arquivos novos sob o UID do PHP, dentro de uma árvore que pertence a outro UID, aumentando a mistura. Use `FS_METHOD` como diagnóstico temporário, para confirmar que o bloqueio é o teste de dono e não uma permissão real de leitura, e remova em seguida.

## Corrigir o dono, não a permissão

A ordem importa: primeiro uniformize o dono, depois normalize o modo, depois trate o diretório de uploads.

### Uniformize o dono da árvore antes de tocar no modo

Como root, ou pelo recurso de correção de propriedade do seu painel:

```bash
# substitua meusite pelo usuario da conta (o dono do codigo)
chown -R meusite:meusite /home/meusite/public_html
```

Se o PHP roda sob o usuário da conta (modelo suEXEC), esse é o alvo. Se o PHP roda como `nobody` ou `www-data`, **não** faça o caminho inverso dando a árvore ao usuário do servidor web: corrija a execução do PHP. A documentação do LiteSpeed sobre [suEXEC](https://docs.litespeedtech.com/lsws/suexec/) trata exatamente da configuração do usuário sob o qual os processos externos são iniciados por virtual host.

### Volte os modos para 755 em diretórios e 644 em arquivos

```bash
cd /home/meusite/public_html
find . -type d -exec chmod 755 {} \;
find . -type f -exec chmod 644 {} \;
chmod 640 wp-config.php
```

Com dono correto, `755` e `644` bastam para o PHP escrever. Se depois disso ainda falhar, o problema não era dono nem modo: olhe ACL, atributos imutáveis (`lsattr`), quota cheia ou `open_basedir`.

### Setgid em uploads mantém o grupo estável, não o usuário

Quando mais de um processo legítimo escreve em `uploads` (PHP e um usuário de deploy, por exemplo), o setgid mantém o grupo estável nos arquivos criados dali em diante:

```bash
chgrp -R meusite wp-content/uploads
chmod -R g+w wp-content/uploads
find wp-content/uploads -type d -exec chmod g+s {} \;
```

`g+s` em diretório faz todo arquivo e subdiretório novo herdar o grupo do diretório pai, em vez do grupo primário de quem criou. Não resolve divergência de **usuário**, só de **grupo**. É complemento do `chown`, não substituto.

### Verifique se sobrou arquivo com dono errado ou gravável por todos

```bash
find . ! -user meusite -o ! -group meusite | head
find . -type d -perm -0002 | head   # diretorios gravaveis por qualquer um
```

As duas listas vazias é o estado desejado. A segunda é o teste que denuncia `777` esquecido.

## Por que `777` é pior do que parece

Em hospedagem com suEXEC, cada conta executa PHP sob o próprio UID, o que já isola contas vizinhas. `777` desfaz parte desse isolamento dentro do servidor: qualquer processo, inclusive um script injetado rodando sob outro contexto, passa a poder gravar naquele caminho. E arquivos `777` em `wp-content` são alvo preferido de reinfecção, porque o backdoor pode se regravar sozinho depois da limpeza.

Há um efeito colateral prático também. Muitos scanners e checklists de segurança marcam diretório gravável por todos como achado. Você corrige o update de plugin hoje e cria um item de auditoria permanente.

## Como reverter um chown -R e o que pode dar errado

`chown -R` é destrutivo quando apontado para o alvo errado. Antes de executar:

- Rode sem alterar nada: `find . -printf '%u:%g %m %p\n' > /tmp/donos-antes.txt`. Esse arquivo é o seu plano de reversão.
- Confirme que o caminho termina em `public_html` ou equivalente, e não em `/home` ou `/`.
- Em servidor compartilhado sem SSH root, use a função de correção de propriedade do painel em vez de tentar via PHP. PHP sem privilégio não consegue dar `chown` para outro usuário.
- Se houver symlink apontando para fora do docroot, prefira `chown -R --no-dereference` para não alterar o alvo externo.
- Em sites com cache de página em disco, limpe o cache depois. Arquivos de cache antigos podem ter sido gerados sob o dono errado e falhar na invalidação.

Plugins de segurança que monitoram integridade vão acusar mudança em massa logo após a correção. É esperado: muda metadado, não conteúdo.

## Seis causas para investigar quando o dono está certo e ainda falha

Esgotado o diagnóstico de dono, a ordem de investigação é:

- `df -h` e a quota da conta. Disco cheio aparece como "could not write".
- `open_basedir` no pool PHP. Caminho fora da lista retorna erro de permissão mesmo com dono correto.
- `disable_functions`. Sem funções de filesystem, o updater falha de outro jeito.
- Atributos estendidos: `lsattr wp-config.php`. Um `i` ali bloqueia até o root.
- SELinux ou AppArmor, em VPS próprio. Contexto errado ignora dono e modo.
- Um plugin de hardening que força `DISALLOW_FILE_MODS` ou reaplica permissões por cron, desfazendo sua correção a cada hora.

O sexto item é o mais sorrateiro: você corrige, testa, funciona, e no dia seguinte volta. Procure por tarefas agendadas e por opções de hardening antes de culpar o servidor.

Se você chegou aqui e o update continua pedindo FTP com dono uniforme, modo `755`/`644` e nenhum dos seis itens acima presente, vale abrir chamado com a saída de `stat -c '%U:%G %a' wp-content wp-content/upgrade` e o resultado do script de `posix_geteuid()` em mãos. Com esses dois dados, o diagnóstico do outro lado leva minutos em vez de rodadas de perguntas.

