Exec Format Error: como resolver no Linux

Solução de problemas

Este guia explica por que surge a mensagem “Cannot Execute Binary File: Exec Format Error”, como diagnosticá-la e quais são as soluções práticas. Inclui comandos, opções para casos especiais (32-bit vs 64-bit, contêineres, emulação) e listas de verificação para usuários, desenvolvedores e administradores.

O que significa “Cannot Execute Binary File: Exec Format Error”?

Erro de execução de binário

Essa mensagem aparece quando o kernel ou o interpretador do sistema detecta que o formato do ficheiro binário não é válido para execução naquele ambiente. Em termos simples: o sistema recebeu um ficheiro que não consegue transformar em código executável para o processador e ambiente atual.

Definição rápida: formato de binário — a forma como o ficheiro foi construído (cabecalho ELF, arquitetura alvo, dependências vinculadas, etc.).

Causas mais comuns

Arquitetura incompatível (ex.: binário ARM em x86_64).
Ficheiro corrompido (download incompleto, checksum divergente).
Permissões inexistentes de execução (modo de ficheiro sem +x).
Formato de executável que precisa de um interpretador ou camada de compatibilidade (por exemplo, binários Windows ou binários ELF para outra ABI).
Ambiente ou variável de execução mal configurados (SHELL, PATH, binfmt_misc mal registado).
Tentativa de executar um ficheiro de texto ou script sem shebang adequado.

Observação: nem todos os erros de execução que aparecem como “Exec Format Error” significam corrupção — muitas vezes é apenas uma incompatibilidade de arquitetura.

Diagnóstico passo a passo

Verifique o tipo/arquitetura do ficheiro:

file ./meu_binario

Saída típica: “ELF 64-bit LSB executable, x86-64” ou “ELF 32-bit LSB executable, ARM”. Compare com a arquitetura do sistema:

uname -m

Confirme integridade do ficheiro (checksums fornecidos pelo fornecedor):

md5sum meu_binario
sha256sum meu_binario

Verifique permissões:

ls -l meu_binario

Se não tiver o bit de execução, ajuste:

chmod +x meu_binario

Tente executar com prefixo explicito (para scripts com shebang):

./meu_binario

Se for um script (texto), abra e verifique o shebang (primeira linha, ex: #!/bin/bash).
Em ambientes de contêiner/CI, confirme que a imagem base corresponde à arquitetura do host ou que existe uma estratégia de emulação.

Correções detalhadas

1) Compatibilidade de arquitetura

Confirme que o binário foi compilado para a mesma arquitetura do seu sistema. Se não, obtenha a versão correta do fornecedor ou recompile a partir do código-fonte para a arquitetura alvo.

Quando obter o binário correto não for possível, considere uma destas abordagens:

Recompilar para a arquitetura do host (se tiver código-fonte).
Usar um contêiner/VM com a arquitetura alvo.
Usar emulação (qemu-user / qemu-user-static) para executar binários de outra arquitetura.

Exemplo: identificar arquitetura

file app
uname -m

Se file mostrar “ARM” e uname -m mostrar “x86_64”, há incompatibilidade.

2) Verificar integridade do ficheiro

Arquivos corrompidos (transferência interrompida, disco com problemas) podem ter cabeçalhos inválidos. Sempre confirme o checksum com o publicado pelo fornecedor. Se os checksums não baterem, descarregue novamente o ficheiro a partir de uma fonte fiável.

Comandos:

sha256sum meu_binario
# comparar com o valor fornecido pelo fornecedor

Se não existir checksum, baixe via um canal seguro (HTTPS) ou peça ao fornecedor.

3) Ajuste de permissões

Sem o bit de execução, o kernel não irá tratar o ficheiro como executável. Conceda a permissão e execute:

chmod +x meu_binario
./meu_binario

Se ainda houver erro, confirme que o ficheiro é mesmo um binário executável e não um script sem shebang.

4) Formato do executável e interpretadores

Alguns binários dependem de um interpretador ou de bibliotecas específicas. Exemplos:

Binários ELF que exigem uma versão específica de libc.
Binários Java, Python ou scripts que exigem um runtime.
Binários Windows (.exe) que não são nativos em Linux.

Soluções:

Instale runtime/libraries necessárias (por exemplo, libc compatível, interpretes).
Para binários Windows, use Wine ou outra camada de compatibilidade.

5) Rodando binários 32-bit em sistemas 64-bit

Em distribuições modernas, o suporte a 32-bit pode estar desativado por padrão. Para Debian/Ubuntu existem abordagens conhecidas:

Ativar multiarch (quando usar pacotes i386):

sudo dpkg --add-architecture i386
sudo apt update
sudo apt install libc6:i386

Alternativamente instalar pacotes de compatibilidade que incluam bibliotecas 32-bit.

Nota: “ia32-libs” era usado antigamente; hoje o multiarch e pacotes específicos são preferíveis.

6) Usar emulação com qemu-user-static

Para executar binários de outra arquitetura sem recompilar, pode configurar qemu-user-static e binfmt_misc. Em linhas gerais:

Instale qemu-user-static.
Registe binfmt para o tipo desejado.
Execute ou crie contêineres que usem esse suporte.

Exemplo conceptual (Debian/Ubuntu):

sudo apt install qemu-user-static
# binfmt_misc pode registar automaticamente ao instalar qemu-user-static

Depois pode executar um binário ARM no x86 usando o binfmt configurado ou executar um contêiner multiarch.

7) Ambiente e variáveis

Verifique se PATH, SHELL ou outras variáveis não estão apontando para programas inesperados. Em alguns casos, um wrapper ou script com o mesmo nome pode estar sendo invocado.

which meu_binario
type -a meu_binario

Esses comandos revelam qual ficheiro está sendo executado.

Casos especiais e quando as correções falham

Se o binário for um instalador para outra plataforma (Windows/macOS), não vai funcionar nativamente no Linux; use Wine, uma VM ou procure versão nativa.
Em sistemas embarcados com ABIs específicas, pode ser necessário toolchain cruzado para recompilar.
Em contêineres baseados em imagem errada (ex.: imagem amd64 num host ARM), o contêiner nem sequer inicia sem emulação.

Fluxograma de decisão

flowchart TD
  A[Começou com Exec Format Error?] --> B{file mostra ELF?}
  B -- Não --> C[É um script/texto? Verificar shebang]
  C --> D[Corrigir shebang ou executar com intérprete]
  B -- Sim --> E{Arquitetura bate com uname -m?}
  E -- Sim --> F{Tem +x e integridade OK?}
  E -- Não --> G[Obter binário correto ou usar qemu/emulação/VM]
  F -- Não --> H[chmod +x e verificar checksum]
  F -- Sim --> I{Dependências presentes?}
  I -- Não --> J[Instalar runtime e bibliotecas necessárias]
  I -- Sim --> K[Provavelmente ambiente mal configurado — rever PATH e wrappers]
  H --> I
  J --> K
  G --> K
  K --> L[Fim: Executar novamente e testar]

Checklists por papel

Usuário final

Confirme que recebeu o ficheiro correto para sua arquitetura.
Verifique permissões (chmod +x).
Confirme integridade (sha256/md5).
Leia documentação do fornecedor para dependências.

Desenvolvedor / Empacotador

Forneça checksums e instruções claras de compatibilidade.
Inclua versões mínimas de runtime nas notas de lançamento.
Considere publicar builds para as arquiteturas populares.

Administrador de Sistemas

Habilite suporte multiarch quando necessário.
Configure qemu/binfmt_misc para ambientes heterogéneos se usar contêineres multi-arch.
Monitorize logs do kernel para mensagens relacionadas a execução (dmesg).

Critérios de aceitação para resolver o problema

O ficheiro executa sem retornar “Exec Format Error”.
O binário não avança para outro erro de dependência (por exemplo, erro de biblioteca faltante) sem antes os problemas de formato serem resolvidos.
Logs confirmam execução correta ou saída esperada do programa.

Mini-metodologia de resolução (passos rápidos)

file + uname -m — confirmar arquitetura.
chmod +x — garantir permissões.
sha256sum — garantir integridade.
which/type -a — garantir que está a executar o ficheiro esperado.
Instalar runtime/libs ou usar emulação/recompilar.

Matriz de compatibilidade (resumo qualitativo)

Binário nativo para x86_64 rodará em sistemas x86_64 nativos.
Binário 32-bit (i386) requer bibliotecas 32-bit em sistema 64-bit ou execução em compatibilidade.
Binários ARM não rodam nativamente em x86 sem emulação/VM.
Binários Windows não rodam em Linux sem Wine/VM.

Segurança e privacidade

Nunca execute binários de origem desconhecida sem verificar checksums e assinatura (se disponível).
Execute ficheiros suspeitos dentro de ambientes isolados (VM ou container) para evitar comprometer o sistema anfitrião.
Verifique assinaturas GPG quando o fornecedor as disponibiliza.

Perguntas frequentes

Por que o file mostra “ELF 64-bit” mas recebo o erro?

Possíveis razões: ficheiro corrompido, dependências faltando ou binfmt/bibliotecas não registadas. Siga os passos de integridade e dependências.

Posso usar qemu para executar qualquer binário de qualquer arquitetura?

Qemu-user permite muita compatibilidade, mas nem sempre garante total suporte a todas as chamadas do kernel ou desempenho adequado. Para aplicações críticas, prefira builds nativos ou VMs.

O que fazer se o ficheiro for um instalador para diferente sistema operacional?

Procure uma versão nativa ou use uma camada de compatibilidade (ex.: Wine para Windows) ou uma VM para o sistema alvo.

Resumo final

“Cannot Execute Binary File: Exec Format Error” é um sinal de incompatibilidade entre ficheiro e ambiente.
Diagnostique com file, uname -m, checksums e permissões.
As soluções vão desde corrigir permissões e rebaixar o ficheiro até usar multiarch, emulação ou recompilar.
Pratique segurança: verifique origem, use ambientes isolados quando estiver em dúvida.

Se ainda tiver dúvidas, descreva exatamente:

Saída de file e uname -m;
Saída de md5/sha256 do ficheiro;
ls -l do ficheiro;
Mensagens completas de erro que recebe.

Referências relacionadas

Como listar grupos no Linux — guias de administração de utilizadores.
Como instalar e usar iTunes no Ubuntu — exemplo de usar camadas de compatibilidade.

Créditos e leituras recomendadas: artigos e guias de administração Linux. Boa sorte na resolução!

Erro “Cannot Execute Binary File: Exec Format Error” — o que é e como resolver