Arreglar Exec Format Error en Linux

Si ves el mensaje Cannot Execute Binary File: Exec Format Error significa que el binario que intentas ejecutar no es compatible con tu entorno. Revisa arquitectura con file y readelf, comprueba integridad con md5sum o sha256sum, fija permisos con chmod +x y, si es necesario, usa emulación con qemu o contenedores. Sigue la lista de diagnóstico y las soluciones detalladas abajo.

Solución de errores

Qué significa Cannot Execute Binary File: Exec Format Error

El mensaje Cannot Execute Binary File: Exec Format Error aparece cuando el kernel no puede interpretar el formato del archivo que se intenta ejecutar. Las causas más habituales son:

Incompatibilidad de arquitectura entre el binario y la CPU del sistema.
Archivo binario corrupto o descarga incompleta.
Falta de permisos de ejecución para el usuario actual.
Formato de ejecutable que requiere un intérprete o capa de compatibilidad inexistente.
Problemas con finales de línea o scripts sin shebang válido que el sistema trata como binarios.
Configuración de entorno o shell que impide la ejecución.

Error de ejecución de binario

Diagnóstico rápido

Pasos rápidos para identificar la causa antes de aplicar soluciones:

Ejecuta file sobre el binario para ver el formato y la arquitectura

file mi_ejecutable

Salida típica: ELF 64-bit LSB executable, x86-64 o ELF 32-bit LSB executable, Intel 80386

Revisa permisos

ls -l mi_ejecutable

Verifica que tenga la x para el usuario que ejecuta.

Comprueba integridad

md5sum mi_ejecutable
sha256sum mi_ejecutable

Compara con el checksum publicado por la fuente.

Inspecciona cabecera ELF y dependencias

readelf -h mi_ejecutable
ldd mi_ejecutable  # puede fallar si la arquitectura no coincide

Intenta ejecutar con strace para ver el fallo del kernel

strace ./mi_ejecutable

Si es un script, abre la primera línea: debe existir un shebang válido como #!/bin/bash

Causas comunes y cómo confirmarlas

Arquitectura incompatible

Qué comprobar: con file y readelf verás si el binario es ELF 32-bit vs ELF 64-bit o si está destinado a ARM, MIPS u otra CPU.
Por qué falla: un binario compilado para ARM no puede ejecutarse sobre una CPU x86_64 sin emulación.

Archivo corrupto o incompleto

Qué comprobar: checksums MD5/SHA o tamaño de archivo frente al esperado.
Señal: descargas interrumpidas producen binarios que no contienen cabecera válida.

Permisos insuficientes

Qué comprobar: bits de permiso. Si falta la x, el kernel no lo ejecutará.

Formato no ejecutable o script con CRLF

Qué comprobar: si file indica texto y la primera línea no comienza por #!, el shell puede intentar interpretar algo que no existe. Los finales de línea Windows CRLF pueden romper el shebang y llevar a errores.

Requerimiento de intérprete o compatibilidad

Qué comprobar: algunos ejecutables son wrappers que invocan un intérprete concreto o necesitan librerías de compatibilidad (por ejemplo, bibliotecas de 32 bits en un sistema 64 bits).

Soluciones paso a paso

1. Comprobar y confirmar la arquitectura

Ejecuta:

file mi_ejecutable
readelf -h mi_ejecutable

Si ves ELF 32-bit en un sistema 64-bit, considera instalar bibliotecas de compatibilidad de 32 bits o ejecutar en un contenedor/emulador.

Ejemplo en Debian/Ubuntu para permitir binarios i386:

sudo dpkg --add-architecture i386
sudo apt update
sudo apt install libc6:i386 libstdc++6:i386

Nota: los nombres exactos de paquetes dependen de la distribución.

2. Volver a descargar el binario y comprobar integridad

Si el checksum no coincide, redescarga el archivo desde la fuente oficial y vuelve a comprobar:

sha256sum mi_ejecutable

Si la fuente publica un sha256, compáralo. Si no, descarga mediante mecanismos fiables.

3. Arreglar permisos de ejecución

Otorga permiso ejecutable y vuelve a intentar:

chmod +x mi_ejecutable
./mi_ejecutable

Si el binario debe ejecutarse como otro usuario, usa sudo o su según corresponda.

4. Detectar scripts mal formados y finales de línea

Si file indica que el archivo es texto, inspecciona la primera línea y los finales de línea:

head -n 1 mi_ejecutable
file mi_ejecutable
dos2unix mi_ejecutable   # convierte CRLF a LF si fuese necesario

Asegúrate de que la primera línea contenga un shebang válido como #!/usr/bin/env bash

5. Usar emulación con qemu para otras arquitecturas

Para ejecutar binarios de otra arquitectura localmente puedes usar qemu-user o qemu-user-static junto con binfmt_misc. En Debian/Ubuntu:

sudo apt install qemu-user-static binfmt-support

Esto permite registrar intérpretes en binfmt_misc para que el kernel invoque qemu cuando se detecte un binario ARM, por ejemplo. Otra opción es usar contenedores preempaquetados con qemu.

6. Ejecutar dentro de un contenedor o máquina virtual

Si la emulación local no es suficiente, arranca una VM o contenedor con la arquitectura adecuada. Docker puede ser útil para aislar el entorno y usar imágenes multiarch:

# ejemplo conceptual
docker run --rm -it --platform linux/arm64 imagen-arm bash

La opción –platform exige soporte del runtime y del host.

7. Cross-compilación o recompilación

Si tienes acceso al código fuente, lo más limpio es recompilar para la arquitectura objetivo:

# pasos generales
mkdir build && cd build
cmake .. -DCMAKE_TOOLCHAIN_FILE=toolchain-file  # o configure/make según el proyecto
make

Si no manejas toolchains, considera compilar dentro de una VM con la arquitectura correcta.

8. Revisar dependencias y bibliotecas compartidas

Si readelf o ldd muestran dependencias faltantes, instala las librerías necesarias. Para binarios 32/64-bit en Debian/Ubuntu, instala los paquetes libc6:arch y libstdc++ correspondientes.

9. Ver SELinux o AppArmor

En sistemas con SELinux o AppArmor, el fallo puede provenir de políticas que impiden la ejecución. Revisa logs de auditd o journalctl y adapta las políticas si procede.

# ejemplo para SELinux
sudo ausearch -m avc -ts recent
sudo journalctl -xe

Casos especiales y cuándo aplicar cada solución

Si file muestra arquitectura diferente: usa emulación, contenedor o recompilación.
Si los checksums no coinciden: redescarga y verifica.
Si falta la x: chmod y vuelve a intentar.
Si es un script: arregla shebang o finales de línea.
Si ldd no funciona por arquitectura distinta: usa qemu/binfmt o reproduce en la plataforma objetivo.

Métodos alternativos y heurísticos rápidos

Heurística 1: Si descargaste desde web y el archivo es pequeño o extraño, primero compara checksum.
Heurística 2: Si el host es ARM o Raspberry Pi y el binario indica x86, reconsidera su origen.
Heurística 3: Si el error aparece tras clonar un repositorio, confirma que el archivo no sea un enlace simbólico roto.

Mini metodología para resolución sistemática

Información: file + readelf + ls -l + md5/sha256
Clasificación: incompatibilidad de arquitectura / corrupción / permisos / formato
Remediación: chmod / redescarga / emulación o recompilación
Verificación: ejecutar, revisar logs, probar en entorno limpio

Checklist por rol

Desarrollador

Confirmar plataforma objetivo en la documentación
Proveer builds multiarch o contenedores
Incluir checksums y firmas

Administrador de sistemas

Verificar paquetes de compatibilidad instalados
Configurar qemu/binfmt si se requiere
Revisar políticas SELinux/AppArmor

Usuario final

Ejecutar file y pedir a soporte la versión correcta
No ejecutar binarios de fuentes no fiables
Pedir instrucciones de compatibilidad

Flujo de decisión (Mermaid)

flowchart TD
  A[Empieza: intento de ejecución] --> B{file muestra ELF y arquitectura}
  B -- Coincide --> C{¿Tiene permiso x?}
  B -- No coincide --> D[Usar emulación o recompilar]
  C -- Sí --> E{Checksum correcto}
  C -- No --> F[chmod +x y ejecutar]
  E -- Sí --> G[Revisar dependencias y entorno]
  E -- No --> H[Redescargar y verificar checksum]
  G --> I[Ejecutar con éxito o revisar logs]
  H --> A
  F --> A
  D --> I

Ejemplos prácticos

Intento ejecutar y file indica ARM en x86_64

$ file mi_app
mi_app: ELF 32-bit LSB executable, ARM, EABI5

Solución: usar qemu-user-static o ejecutar en máquina ARM.

Archivo de texto sin shebang

$ file mi_script
mi_script: ASCII text
$ head -n 1 mi_script
#!/bin/sh

Si ves un retorno de carro CRLF, ejecuta dos2unix y asegúrate de que el intérprete exista.

Buenas prácticas para evitar el error

Publicar las arquitecturas soportadas y checksums junto a los binarios.
Proveer builds para x86_64 y ARM cuando sea posible.
Documentar dependencias de librerías y versiones.
Empaquetar binarios en contenedores si la portabilidad es un requisito.

Cuándo no aplicar estas soluciones

Si el binario es malicioso, no intentes forzarlo: descártalo.
Si no confías en la fuente, mejor recompilar desde código conocido o usar paquetes oficiales.

Notas de seguridad y privacidad

No ejecutes binarios de fuentes no verificadas sin analizarlos primero.
Mantén registros de acciones administrativas y evita su ejecución como root salvo cuando sea necesario.

Resumen final

Importante: Ejecutar un binario equivale a permitir que el código se ejecute en tu máquina. Antes de aplicar remedios, identifica claramente si el problema es de arquitectura, integridad, permisos o formato. Usa emulación o contenedores cuando la recompilación no sea viable. Documenta la solución y añade checksums para futuras descargas.

Si aún tienes dudas, describe el output de los comandos file, readelf -h y ls -l y se podrá precisar la solución.

Notas

Si necesitas pasos específicos para Debian, Ubuntu, Fedora o Arch, indica la distribución y la arquitectura y añado comandos concretos.

Créditos y lecturas relacionadas

Hannah Montana Linux: What is It Better than other Distro by J. Shanmugam
How to List Groups in Linux by K. Masoun
How to Install and Use iTunes on Ubuntu? by Shruti Gupta

Cómo solucionar Cannot Execute Binary File: Exec Format Error