# mcrypt sumiu do PHP na 7.2: congelar ou migrar

A extensão não está desligada, ela saiu da linguagem. Como provar isso na conta do cliente, escolher entre congelar a pasta em 7.1 ou reescrever para openssl, e testar na ordem que pega o erro calado.

> o mcrypt foi removido do núcleo do PHP na versão 7.2 e virou pacote PECL, que só pode ser compilado por quem tem root. Em hospedagem compartilhada não há caixinha para marcar: ou você congela a pasta do sistema legado em PHP 7.1, ou troca as chamadas por openssl_encrypt e recifra o dado já gravado.

João Rizzon · 2026-09-26 · Painéis

---

## A extensão não está desligada, ela não existe mais

Quando um sistema antigo quebra por falta de `imap` ou `zip`, o roteiro é conhecido: abre o seletor de PHP do painel, marca a caixinha, salva, testa. Com mcrypt esse roteiro termina em um beco. A caixinha não está desmarcada. Ela não está lá.

O motivo é anterior ao painel: o mcrypt foi removido do núcleo do PHP na versão **7.2** e passou a existir apenas como pacote PECL, que precisa ser compilado no servidor por quem tem root. Não é uma decisão da hospedagem, é do projeto PHP. Por isso a busca "como ativar mcrypt no cPanel" leva o leitor a artigos de ativação de extensão que não resolvem o caso dele: o problema não é marcar uma opção, é que a peça saiu do núcleo da linguagem.

A documentação do cPanel mantém uma página para o módulo ([PHP Module: mcrypt](https://docs.cpanel.net/ea4/php/php-module-mcrypt/)), e é aí que muita gente se engana. Essa página descreve o módulo dentro do catálogo do EasyApache 4. Catálogo não é inventário. O que existe no catálogo do EA4 e o que **este** servidor, com **estas** versões de PHP instaladas, entrega para **esta** conta são três coisas diferentes. Documentação nenhuma responde a última. Só a conta responde.

Então o trabalho é outro: provar a ausência na conta do cliente, decidir entre os caminhos possíveis, cada um com um custo diferente, e testar na ordem que pega o erro silencioso. Nenhuma das três etapas é um clique.

## Provar a ausência em três lugares, do mais barato ao mais caro

Antes de propor qualquer coisa ao cliente, feche a prova. São três olhares, do mais barato ao mais caro.

### Onde o mcrypt é chamado dentro do código legado

Sem saber o tamanho do estrago, não há orçamento. Pelo terminal ou pelo Gerenciador de Arquivos, varra o diretório do sistema legado:

```bash
grep -rn "mcrypt_" --include="*.php" ~/public_html | head -50
grep -rc "mcrypt_" --include="*.php" -r ~/public_html | grep -v ":0$"
```

O primeiro comando mostra as linhas. O segundo conta ocorrências por arquivo e joga fora os zeros, que é o que você cola no orçamento. Repare no que aparece: `mcrypt_encrypt`, `mcrypt_decrypt`, `mcrypt_create_iv`, `mcrypt_get_iv_size`. Se as chamadas estão concentradas em um arquivo de classe (algo como `class.crypt.php`), a reescrita é pequena. Se estão espalhadas em trinta controladores, o orçamento muda de faixa.

### A lista de extensões do seletor de PHP, versão por versão

No cPanel, a lista de extensões marcáveis de cada versão fica em **Selecionar versão do PHP**. Troque a versão no seletor e leia a lista de cada uma, uma por uma. Não confunda com as telas vizinhas: o **MultiPHP Manager** só define qual versão cada domínio usa, e o **MultiPHP INI Editor** só edita diretivas do `php.ini`. Nenhum dos dois lista extensões.

É um clique por versão e é a prova que o cliente entende: a lista de 7.4, a de 8.0, a de 8.2, nenhuma tem a linha `mcrypt`. Tire print. Esse print encerra a discussão de "mas o outro servidor tinha".

O mcrypt esteve no núcleo do PHP até a 7.1 inclusive. Ou seja, ele só pode aparecer marcável em 7.1 ou anterior (7.0, 5.6), e apenas se o servidor ainda oferecer essas versões no seletor. Ver na lista é a única confirmação válida.

### O php -m do binário certo, quando houver SSH

Com acesso SSH, o comando é direto, mas tem uma armadilha:

```bash
php -v
php -m | grep -i mcrypt
```

O `php` do seu shell é o CLI, e o CLI pode estar em uma versão diferente da que o site usa via handler. Para checar uma versão específica do EA4, chame o binário dela:

```bash
/opt/cpanel/ea-php71/root/usr/bin/php -m | grep -i mcrypt
/opt/cpanel/ea-php74/root/usr/bin/php -m | grep -i mcrypt
```

Saída vazia significa ausente. Para ter certeza absoluta do que o **site** carrega, um arquivo temporário com `<?php phpinfo();` na pasta do sistema e um `Ctrl+F` por mcrypt resolve. Apague o arquivo depois, sem exceção.

## As duas saídas possíveis e o que cada uma custa

Em hospedagem compartilhada são duas: ou o código roda numa versão de PHP que ainda tem a extensão no núcleo (7.1 ou anterior), ou o código deixa de chamar a extensão.

Existe uma terceira via, mas ela não é sua se a conta é compartilhada: em PHP 7.2 ou superior, o mcrypt pode ser compilado via PECL. Isso exige acesso root, ou seja, VPS ou dedicado, e depende de o administrador aceitar manter no servidor uma extensão abandonada pelo projeto PHP. Em plano compartilhado não há como fazer isso, e mesmo em VPS é uma ponte, não um destino: você ganha tempo para a reescrita sem ganhar suporte.

| Critério | Congelar a pasta em PHP 7.1 | Trocar por `openssl_encrypt` |
|---|---|---||
| Prazo de execução | horas | dias a semanas, conforme a varredura do `grep` |
| Correção de segurança do PHP | não recebe mais | versão suportada |
| Dado já gravado | continua legível, nada muda | precisa de rotina de recifragem |
| Risco imediato | superfície antiga exposta na web | bug de cifragem em produção |
| Depende do servidor | sim, a versão 7.1 precisa existir lá | não |
| Resolve o problema | não, adia | sim |

Congelar é legítimo como ponte, não como destino. Se você vender como destino, o problema volta para você no dia em que o servidor aposentar o 7.1, e vai voltar sem prazo e com o cliente achando que já pagou por isso.

## Congelar em PHP 7.1 sem derrubar o resto da conta

Rodar a conta inteira em 7.1 para agradar um sistema legado é o erro clássico: o WordPress do cliente, que estava em 8.x, desce junto e passa a rodar numa versão sem correção. O caminho é versão por diretório: a raiz fica na versão atual e só a pasta do sistema antigo fica em 7.1.

Na prática, o jeito mais previsível é criar um subdomínio apontando para a pasta do sistema legado (por exemplo `sistema.dominio.com.br` com raiz em `/public_html/sistema`) e, no **MultiPHP Manager**, definir a versão 7.1 só para esse subdomínio. O painel escreve o handler no `.htaccess` daquela pasta e o resto da conta continua na versão atual. Depois de salvar, confirme com um `phpinfo()` temporário dentro da pasta: se a versão mostrada não for a 7.1, o `.htaccess` da raiz está sobrescrevendo a regra.

Três cuidados que fazem diferença depois:

- **Tire a pasta do alcance público onde der.** Se o sistema é usado só por funcionários, proteja o diretório com o Directory Privacy do cPanel (autenticação HTTP) e, quando possível, restrinja o acesso por IP no `.htaccess` ou no firewall do painel. Uma aplicação antiga em PHP sem correção, aberta na internet, é convite.
- **Desative o que não é usado.** Se o sistema não envia e-mail nem baixa arquivo externo, não deixe função de rede e upload disponíveis sem necessidade.
- **Escreva o prazo no orçamento.** Literalmente: "congelamento válido até dd/mm/aaaa, a partir dessa data a migração do trecho de criptografia é obrigatória e está orçada em X". Sem essa linha, o congelamento vira permanente e o passivo é seu.

## Reescrever com openssl_encrypt é migração de dados, não troca de função

O conselho que circula na internet é "substitua `mcrypt_encrypt` por `openssl_encrypt`". Como troca de linha, funciona. Como plano, não, porque o dado que já está no banco foi cifrado com as regras do mcrypt, e essas regras não são as do OpenSSL por padrão.

Dois detalhes explicam quase todos os casos de "gravou e agora não abre":

- **Padding com zeros.** O `mcrypt_encrypt` completa o bloco com bytes nulos. O `openssl_encrypt` usa PKCS#7 por padrão. Decifrar um dado do mcrypt sem informar padding zero devolve lixo ou `false`.
- **Nome do algoritmo.** `MCRYPT_RIJNDAEL_128` é AES, porque o bloco tem 128 bits. Qual AES depende do tamanho da chave que o código passou, e o mcrypt completava a chave curta com zeros até o próximo tamanho válido. Uma chave de 16 bytes é `aes-128-cbc`, não `aes-256-cbc`. Já `MCRYPT_RIJNDAEL_256` **não é AES**: é Rijndael com bloco de 256 bits, e o OpenSSL não implementa isso. Não existe equivalente.

| O que o código legado usa | Equivalente no OpenSSL | Observação |
|---|---|---||
| `MCRYPT_RIJNDAEL_128` + chave de 16 bytes | `aes-128-cbc` | exige padding zero na leitura do dado antigo |
| `MCRYPT_RIJNDAEL_128` + chave de 32 bytes | `aes-256-cbc` | idem |
| `MCRYPT_RIJNDAEL_256` | não existe | só decifra em PHP 7.1 ou anterior (mcrypt no núcleo) ou em 7.2+ com mcrypt compilado via PECL, o que exige root |
| `MCRYPT_MODE_ECB` | `aes-128-ecb` e afins | sem IV, e sem confidencialidade aceitável hoje |

Exemplo de leitura do dado antigo já em PHP 7.2 ou superior, sem mcrypt instalado (exemplo fictício, valide com o seu caso antes de rodar em produção):

```php
<?php
// EXEMPLO: ler um valor cifrado com mcrypt_encrypt(MCRYPT_RIJNDAEL_128, ..., MCRYPT_MODE_CBC, $iv)
$claro = openssl_decrypt(
    $cifrado,                  // bytes crus, não base64
    'aes-128-cbc',             // depende do tamanho da chave original
    $chave16,                  // exatamente 16 bytes
    OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING,
    $iv
);
$claro = rtrim($claro, "\0"); // remove o padding de zeros do mcrypt
```

E a gravação nova, já no formato que você vai manter (exemplo fictício):

```php
<?php
// EXEMPLO: novo formato, padding PKCS#7 padrão, IV novo a cada registro
$iv = random_bytes(16);
$cifrado = openssl_encrypt($claro, 'aes-256-cbc', $chave32, OPENSSL_RAW_DATA, $iv);
// guarde o IV junto do dado; sem o IV o registro é irrecuperável
```

O ponto que muda o escopo do trabalho: se `MCRYPT_RIJNDAEL_256` aparecer no `grep`, a recifragem **tem** que rodar em um ambiente com mcrypt disponível, isto é, PHP 7.1 ou anterior, ou 7.2+ com o PECL compilado por quem tem root. Você lê com mcrypt, grava com openssl, uma vez, e só então move o sistema de versão. Isso é uma janela de manutenção com backup do banco feito antes, não um deploy de sexta à tarde.

E guarde uma marca de formato no registro (um prefixo, uma coluna `cripto_versao`), senão você não vai saber quais linhas já foram convertidas se a rotina parar no meio.

## A ordem de teste que pega o erro silencioso

Terminada a mudança, o erro barulhento aparece sozinho: `Call to undefined function mcrypt_encrypt()` estoura na tela em PHP 7.2 e acima. O perigoso é o erro calado, aquele em que a decifragem falha, o código compara com `false` e a tela mostra "usuário ou senha inválidos". Testar na ordem certa é o que separa os dois.

### Login de um usuário criado antes da mudança

Não o que você acabou de criar. O usuário recém-criado teve a senha gravada no formato novo e vai entrar mesmo que a leitura do formato antigo esteja quebrada. Pegue uma conta criada há anos, peça a senha ao cliente ou use uma conta de teste que já existia antes da mudança. Esse é o teste que encontra o problema de padding.

### Gravar um campo cifrado por um formulário real

Cadastro de cliente, dados bancários, CPF, o que o sistema cifrar. Preencha e salve. O objetivo aqui não é ver a tela de sucesso: é confirmar que gravou.

### Reler o registro recém-gravado na tela de edição

Abra de volta o registro do passo 2 na tela de edição. Campo vazio, campo com caracteres estranhos ou campo com um rabicho de bytes nulos no fim significa que a gravação e a leitura estão usando regras diferentes. É um erro que só aparece nesta terceira etapa, porque os dois primeiros passos retornam sucesso.

### Abrir um relatório que decifra muitos registros de uma vez

Se o sistema tem uma tela que lista muitos registros cifrados, abra. É onde um registro antigo esquecido pela rotina de recifragem se revela, geralmente derrubando a página inteira.

## Onde ler o erro, e onde não adianta procurar

Em cPanel não há, por padrão, um arquivo `~/logs/error_log` pronto esperando por você. Procurar por ele e não achar já custou tarde de gente boa. Três lugares funcionam:

- **A interface de Erros do painel**, na seção de métricas. Mostra as últimas entradas do log de erro da conta. É o caminho mais rápido e não exige SSH, o que ajuda quando o acesso que o cliente te deu é só o painel.
- **O arquivo do domínio dentro de `~/logs`**, via SSH ou Gerenciador de Arquivos. O nome varia conforme a configuração do servidor, então descubra em vez de adivinhar:

```bash
ls -lt ~/logs | head
```

O `-lt` ordena pelo mais recente, que é justamente o que acabou de receber o seu erro. Depois é só acompanhar o arquivo certo enquanto você refaz o teste:

```bash
tail -f ~/logs/NOME_DO_ARQUIVO_QUE_APARECEU
```

- **O `error_log` que o próprio PHP cria na pasta do script.** Em sistema legado é o destino mais comum do fatal, porque a aplicação roda com `log_errors` ligado e sem `error_log` definido. Vasculhe a árvore:

```bash
find ~/public_html -name error_log -newermt '-1 day' -printf '%TY-%Tm-%Td %TH:%TM %s %p\n'
```

O arquivo costuma estar exatamente no diretório onde a chamada quebrou, o que já entrega metade do diagnóstico.

Se o sistema legado engole exceções (`try/catch` mudo, ou `@` antes das chamadas), nada vai chegar ao log. Nesse caso, ligue temporariamente `display_errors` e `error_reporting`, mas cuidado com o escopo: o MultiPHP INI Editor aplica por domínio ou por conta, ou seja, você ligaria a exibição de erro no site inteiro do cliente. Para restringir ao diretório do sistema, crie um `.user.ini` na pasta (funciona com PHP-FPM ou CGI):

```ini
display_errors = On
error_reporting = E_ALL
```

O `.user.ini` é lido em cache, com atualização tipicamente a cada 300 segundos (`user_ini.cache_ttl`), então espere alguns minutos ou reinicie o pool de PHP do domínio pelo painel antes de concluir que não funcionou. Em handler DSO ou suPHP, o equivalente é um `php.ini` local na mesma pasta. Teste, apague o arquivo em seguida: deixar ligado em produção expõe caminho de arquivo e detalhe de conexão.

## Checklist para varrer a carteira e a frase para o cliente

Se você atende dezenas de sites, faça isso uma vez por conta e guarde o resultado numa planilha. A pergunta volta, e voltar com a resposta pronta vale mais do que refazer o diagnóstico.

| Item | Onde olhar | O que encerra a linha |
|---|---|---||
| Há chamada a mcrypt? | `grep -rn "mcrypt_" --include="*.php"` na pasta do sistema | contagem de arquivos e de ocorrências |
| Qual algoritmo e tamanho de chave? | as linhas do `mcrypt_encrypt` retornadas | RIJNDAEL_128 ou 256, chave de 16/24/32 bytes |
| Existe dado já cifrado no banco? | tabelas com coluna de valor cifrado | sim/não e volume aproximado de linhas |
| Versão de PHP que a pasta usa hoje | MultiPHP Manager | versão por domínio ou subdomínio |
| O servidor ainda oferece 7.1 ou anterior? | lista de versões em Selecionar versão do PHP | sim/não, com print |
| A pasta legada está pública? | URL direta no navegador | protegida por senha e/ou IP |
| Existe backup do banco recente? | gerenciador de backup do painel | data do último dump restaurável |
| Decisão registrada com prazo | orçamento assinado | data limite do congelamento |

E a frase para o cliente, que evita a conversa de "mas é só marcar uma caixinha". Adapte o nome do sistema e mande por escrito, não por telefone:

> **** O componente de criptografia que o seu sistema usa foi retirado do PHP pelos próprios desenvolvedores da linguagem na versão 7.2. Não é uma configuração desligada no servidor: ele não existe em nenhuma versão atual de PHP em hospedagem compartilhada. Há dois caminhos. O primeiro é manter essa parte do site rodando numa versão antiga do PHP por um prazo definido, com a pasta isolada e ciente de que essa versão não recebe mais correção de segurança. O segundo é ajustar o código e converter os dados que já estão gravados para o novo formato, o que é um trabalho de migração com janela de manutenção e backup. O primeiro caminho é mais rápido e adia o custo. O segundo resolve. Preciso da sua decisão para seguir.

Duas notas finais de quem vai executar. Primeira: se a busca que te trouxe aqui foi "como ativar mcrypt", e você chegou nela depois de ler um guia de ativar `imap`, `intl`, `soap` ou `zip` pelo seletor de PHP, o guia estava certo e só não se aplica: aquelas extensões estão no catálogo e são marcáveis, esta não está. Segunda: se o sistema legado for de terceiros e ainda tiver fabricante vivo, pergunte antes de reescrever. Uma versão mais nova do produto pode já ter feito essa migração, e comprar a atualização costuma sair mais barato que refazer a criptografia de outra pessoa.

