Come risolvere l'errore "Cannot Execute Binary File: Exec Format Error"

Affrontare un messaggio come “Cannot Execute Binary File: Exec Format Error” può essere frustrante ma la causa è in genere uno di pochi problemi tecnici ben noti: incompatibilità di architettura, permessi mancanti, formato eseguibile non riconosciuto o file corrotto. Questo articolo spiega, passo dopo passo, come diagnosticare e risolvere l’errore, con comandi e alternative pragmatiche per sviluppatori, amministratori e utenti finali.

Cosa significa “Cannot Execute Binary File: Exec Format Error”

Definizione rapida: Un file binario eseguibile è un file compilato per una specifica architettura CPU e per un formato eseguibile (ad es. ELF su Linux). L’errore “Cannot Execute Binary File: Exec Format Error” viene generato quando il kernel o la shell non riescono a eseguire il file perché il formato o l’architettura non sono compatibili, oppure perché manca il permesso di esecuzione o il file è danneggiato.

Termine in una riga: ELF — formato binario comune su Linux; architettura — x86_64, i386, armhf, aarch64; interpreter — loader dinamico che occorre a molti binari.

Principali cause

• Incompatibilità di architettura tra file ed hardware (ad es. binario x86 su CPU ARM).
• Formato eseguibile non riconosciuto o script senza shebang valido.
• File corrotto (download incompleto, checksum errata).
• Permessi mancanti (manca il bit eseguibile).
• Mancanza dell’interpreter o delle librerie richieste (compatibilità dinamica).
• Ambiente o shell mal configurata (PATH, chroot errato).

Diagnosi rapida (passi veloci)

1. Controlla che il file sia realmente un eseguibile: file my_executable
2. Verifica l’architettura della macchina: uname -m
3. Controlla permessi: ls -l my_executable
4. Prova a eseguire come ./my_executable (assicurati del percorso)
5. Controlla integrità: sha256sum my_executable e confronta con lo SHA fornito
6. Se è uno script, aprilo e verifica l’intestazione shebang (prima riga #!/bin/...)

Esempio di comandi utili:

file my_executable
uname -m
ls -l my_executable
sha256sum my_executable
readelf -h my_executable
ldd my_executable

Note rapide sui comandi:

• file dice se il file è ELF, script di testo, etc.
• readelf -h mostra l’header ELF e l’ABI.
• ldd mostra le dipendenze dinamiche (se il file è un eseguibile dinamico).

Soluzioni passo a passo

1) Verificare la compatibilità dell’architettura

Per prima cosa assicurati che l’architettura dichiarata dal file corrisponda a quella del sistema.

Esempio:

$ file my_executable
my_executable: ELF 64-bit LSB executable, x86-64, ...

$ uname -m
armv7l

Se file riporta x86-64 e la macchina è armv7l hai un’incompatibilità: il binario è per x86_64 mentre la CPU è ARM.

Soluzioni:

• Scarica il binario per la tua architettura.
• Se hai il sorgente, ricompila per la tua architettura.
• Per test o compatibilità user-space installa un emulatore (vedi sez. Emulazione).

2) Controllare l’integrità del file

Se il file è stato scaricato, verifica checksum e firma (se disponibili). Un download interrotto o corrotto può causare un file non eseguibile.

Comandi:

sha256sum my_executable
md5sum my_executable

Confronta il risultato con il checksum pubblicato dalla fonte. Se non coincidono, riscarica il file da una fonte affidabile.

3) Verificare e applicare i permessi di esecuzione

Se il file è corretto e compatibile ma non ha il bit eseguibile, concedilo:

chmod +x my_executable
./my_executable

Se esegui il binario come utente non privilegiato potresti avere ancora errori per mancanza di permessi su risorse esterne; prova con sudo solo se necessario.

4) Gestire formati incompatibili e interpreter mancanti

Alcuni binari non sono eseguibili direttamente: potrebbero richiedere un interpreter (ad esempio uno script con shebang) o un loader. Controlla la prima riga se è uno script o usa readelf -h su ELF.

Se il binario richiede una versione specifica del loader o librerie dinamiche, installa le librerie mancanti o il pacchetto compatibile (multiarch) sulla tua distro.

Esempi (Debian/Ubuntu):

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

Su RHEL/CentOS:

yum install glibc.i686

Queste azioni servono per eseguire binari a 32-bit su sistemi a 64-bit quando esiste compatibilità ABI.

5) Caso speciale: 32-bit su 64-bit

Molti sistemi moderni 64-bit possono eseguire codice a 32-bit ma necessitano delle librerie di compatibilità appropriate. Se il file indica ELF 32-bit, segui i passi di multiarch o installa i pacchetti i386/i686.

Se la tua distribuzione non supporta più i pacchetti legacy, considera l’uso di container o di una VM con la corretta architettura.

6) Emulazione e compatibilità cross-arch

Quando non è possibile ottenere un binario per l’architettura, si può usare un emulatore:

• qemu-user (qemu-user-static) per eseguire binari ARM su x86 e viceversa in user-space.
• Virtual machine (QEMU-system, VirtualBox) per eseguire un intero sistema operativo guest.
• Container con binari della stessa architettura (ad es. Docker + qemu binfmt_misc per multi-arch).

Esempio rapido con qemu-user-static su Debian/Ubuntu:

apt install qemu-user-static
qemu-x86_64 my_executable   # esegue un binario x86_64 su altra arch.

Attenzione: l’emulazione può essere lenta e non sempre completa (alcune istruzioni o syscall potrebbero comportarsi diversamente).

7) Ricompilare il codice sorgente

Se hai accesso al codice sorgente, la soluzione più pulita è ricompilare per la tua architettura:

./configure --host=arm-linux-gnueabihf
make
make install

O usare cross-compiler toolchain (gcc cross, clang cross) se lavori su architettura diversa.

8) Quando è uno script

Se il file non è binario ma uno script (Bash, Python, Perl), assicurati che la prima riga (shebang) punti a un interpreter valido:

#!/usr/bin/env bash

Oppure esegui esplicitamente l’interprete:

bash my_script
python3 my_script.py

Checklist per ruolo

Sviluppatore

• Fornire build per le architetture più comuni (x86_64, i386, armhf, aarch64).
• Documentare dipendenze e checksum.
• Includere script di build e Dockerfile per riproducibilità.

Amministratore di sistema

• Abilitare multiarch o installare pacchetti compatibilità.
• Usare qemu, chroot o VM per testare binari cross-arch.
• Mantenere repository interni con build certificate.

Utente finale

• Controllare file e uname -m prima di eseguire.
• Non eseguire binari da fonti non verificate; controllare checksum e firme.
• Usare container o VM per testare eseguibili sospetti.

Playbook operativo (SOP) per correggere l’errore

1. Eseguire la diagnosi rapida (vedi sezione Diagnosi rapida).
2. Se l’architettura non corrisponde, cercare la build corretta o usare emulazione.
3. Verificare checksum; riscaricare se necessario.
4. Aggiornare permessi con chmod +x e riprovare.
5. Se il problema persiste, usare strace per vedere il punto di fallimento: strace ./my_executable.
6. Considerare la ricompilazione o la richiesta di una build compatibile dal fornitore.

Esempi di output e interpretazione

• file restituisce “ELF 64-bit LSB executable, x86-64” ma uname -m restituisce “aarch64”: incompatibilità di architettura.
• ldd my_executable mostra “not a dynamic executable”: il binario potrebbe essere statico o non ELF.
• Tentativo di esecuzione produce ancora “Exec format error” dopo chmod +x: probabilmente il kernel non riconosce il formato (architettura o header corrotto).

Decisione rapida (diagramma)

flowchart TD
  A[Inizio: ricevi Exec Format Error] --> B{file è ELF o script?}
  B -- Script --> C[Verifica shebang] --> D{shebang valido?}
  D -- Sì --> E[Esegui con interpreter esplicito]
  D -- No --> F[Aggiorna shebang o esegui interpreter]
  B -- ELF --> G[Controlla architettura con file/readelf]
  G --> H{Architettura corrisponde a uname -m?}
  H -- Sì --> I[Controlla permessi e integrità]
  H -- No --> J[Scarica binario corretto o usa emulatore]
  I --> K{Permessi OK?}
  K -- No --> L[chmod +x e riprova]
  K -- Sì --> M[Verifica dipendenze e interpreter dinamico]
  M --> N{Dipendenze presenti?}
  N -- No --> O[Installa librerie / multiarch]
  N -- Sì --> P[Se persiste, usa strace/readelf per debug avanzato]

Compatibilità architetture (matrice sintetica)

Test di accettazione e casi di prova

• Caso 1: binario x86_64 su macchina x86_64
  • Expect: file mostra x86_64, ./my_executable parte. Se no, verificare permessi, dipendenze.
• Caso 2: binario i386 su x86_64 con multiarch configurato
  • Expect: l’eseguibile parte dopo l’installazione delle librerie i386.
• Caso 3: binario ARM su x86_64
  • Expect: non parte nativamente; con qemu-user dovrebbe partire (testare funzioni base).
• Caso 4: script senza shebang
  • Expect: errore Exec Format; eseguire con bash script risolve.

Criteri di accettazione

• Il binario lanciato in un ambiente matching la sua architettura si avvia senza errori di formato.
• Per binari multiarch, le librerie di compatibilità sono installate e ldd non restituisce librerie mancanti.

Considerazioni sulla sicurezza

Eseguire un binario sconosciuto comporta rischi. Prima di eseguirlo:

• Controlla checksum e firma digitale se disponibile.
• Esegui il binario in una sandbox, container o VM isolata.
• Non lanciare con privilegi di root a meno che non sia strettamente necessario.

Quando queste soluzioni non funzionano

• Il file è parzialmente corrotto in modo non evidente: può sembrare un ELF ma avere header danneggiati. In questo caso la ricreazione o la riscarica da una fonte verificata è l’unica soluzione pratica.
• Il binario usa istruzioni CPU non emulate o speciali estensioni hardware: l’emulazione può fallire o causare malfunzionamenti.

Glossario rapido

• ELF: formato binario comune su Linux.
• Shebang: prima riga di script che indica l’interprete (es. #!/usr/bin/env bash).
• Multiarch: supporto per eseguire pacchetti di diverse architetture su una sola macchina.
• QEMU: emulatore/virtualizzatore che permette l’esecuzione cross-arch.

FAQ

Perché file dice ELF ma l’esecuzione fallisce con Exec Format Error?

Perché l’ELF può essere per una diversa architettura (es. x86_64 vs ARM). Controlla uname -m e readelf -h.

Posso convertire un eseguibile da x86 a ARM?

No, non si può convertire direttamente un binario. Devi ricompilare il software per l’architettura target o usare emulazione.

È sicuro usare qemu per testare binari esterni?

Sì per scopi di test se il sistema è isolato; evita esecuzione di binari non verificati su host di produzione.

Riepilogo

• Controlla sempre file, uname -m, permessi e checksum.
• Se l’architettura non corrisponde, scarica la build corretta, ricompila o usa emulazione.
• Per binari 32-bit su 64-bit installa le librerie di compatibilità (multiarch) quando possibile.
• Proteggi l’esecuzione di binari non trusted con sandbox/VM e verifica firme/checksum.

Short announcement: Se incontri “Cannot Execute Binary File: Exec Format Error”, non è un bug misterioso: è quasi sempre incompatibilità di formato/architettura o un problema di permessi/integrità. Segui la diagnosi rapida, valuta emulazione o ricompilazione, e mantieni sempre l’esecuzione isolata per la sicurezza.

Se hai domande specifiche (output dei comandi, architettura del file, distribuzione Linux), incolla gli output di file my_executable e uname -m nei commenti per assistenza mirata.