Erreur Cannot Execute Binary File: Exec Format Error — Guide complet

Qu’est-ce que l’erreur Cannot Execute Binary File: Exec Format Error ?

L’erreur « Cannot Execute Binary File: Exec Format Error » apparaît lorsque le noyau (ou le shell/interpréteur) ne peut pas exécuter un fichier binaire donné. C’est un symptôme, pas une cause unique : il indique que l’exécutable n’est pas utilisable « tel quel » sur le système courant. Les causes fréquentes sont : incompatibilité d’architecture, format exécutable différent, fichier corrompu, absence de permission d’exécution ou dépendances/interpréteur manquants.

Important : « binaire » désigne un fichier compilé (non texte) destiné à une architecture et à un format précis. Un « interprété » comme un script shell doit commencer par un shebang valide pour être exécuté directement.

Variantes d’intention recherchée

• Corriger Cannot Execute Binary File
• Exec Format Error Linux dépannage
• binaire incompatible architecture
• qemu exécution cross-architecture
• erreurs chmod et shebang

Symptômes courants et exemples

• Tentative : ./mon_programme → « Cannot execute binary file »
• Tentative : bash mon_programme (si binaire, affichera données non lisibles)
• Tentative : file mon_programme → indique ELF 32-bit LSB or ELF 64-bit LSB, architecture différente
• Tentative : sh mon_script.sh → « bad interpreter: No such file or directory » (shebang Windows CRLF possible)

Causes détaillées

• Incompatibilité d’architecture CPU : binaire compilé pour i386 vs x86_64, arm vs aarch64, MIPS, PowerPC, etc.
• Format exécutable non reconnu : fichier non-ELF sur Linux, binaire PE Windows, ou script sans shebang.
• Fichier corrompu ou téléchargement incomplet : checksum incorrect.
• Droits manquants : pas d’autorisation d’exécution pour l’utilisateur courant.
• Shebang incorrect ou CRLF Windows -> utiliser dos2unix.
• Manque de couche d’exécution/compatibilité : besoin de qemu-user, bibliothèques i386, ou chroot/container.
• Mauvaise invocation : tenter d’exécuter un binaire compilé pour une autre plateforme via sh ou bash.

Dépannage pas à pas (SOP rapide)

1. Identifier le message exact et le contexte (serveur, container, machine locale).
2. Vérifier le type/architecture du fichier : file, readelf, objdump.
3. Vérifier l’architecture du système : uname -m.
4. Vérifier les permissions : ls -l et chmod +x si nécessaire.
5. Vérifier l’intégrité : sha256sum/md5sum comparé à la source.
6. Si architectures différentes : installer compatibilité (multiarch, qemu) ou télécharger la bonne version.
7. Tester dans un conteneur/opération isolée avant de déployer.

Commandes de base et exemples

Vérifier le type de fichier et l’architecture détectée :

file my_executable
# Exemples de sortie :
# my_executable: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked
# my_executable: PE32 executable (GUI) Intel 80386, for MS Windows

Vérifier l’architecture de la machine :

uname -m
# x86_64, i686, armv7l, aarch64, etc.

Lire l’en-tête ELF pour plus de détails :

readelf -h my_executable

Vérifier les dépendances d’un binaire dynamique :

ldd my_executable

Vérifier l’intégrité :

sha256sum my_executable
md5sum my_executable

Donner le droit d’exécution :

chmod +x my_executable
./my_executable

Convertir un script Windows CRLF en LF Unix :

dos2unix mon_script.sh

Fix 1 — Vérifier la compatibilité du binaire avec le CPU et l’OS

Pourquoi : un exécutable est compilé pour une architecture précise. Si elle ne correspond pas, le noyau ne peut pas l’exécuter.

Étapes :

• Exécutez file my_executable et uname -m.
• Comparez les résultats : s’ils diffèrent (par ex. ELF 32-bit vs machine 64-bit, ou ARM vs x86), vous avez trouvé la cause.

Solutions :

• Téléchargez ou compilez une version correspondant à votre architecture.
• Si vous avez seulement un binaire 32-bit sur une machine 64-bit, installez les bibliothèques 32-bit (voir section multiarch).
• Utilisez qemu-user pour exécuter des binaires d’une autre architecture si nécessaire.

Fix 2 — Contrôler l’intégrité du fichier

La corruption pendant le téléchargement provoque un format inattendu.

Étapes :

• Obtenez le sha256/sha512 fourni par la source.
• Exécutez sha256sum my_executable et comparez.
• En cas de différence, retéléchargez depuis une source fiable ou utilisez une autre release.

Remarque : évitez d’exécuter des binaires non signés trouvés au hasard — risque de sécurité.

Fix 3 — Corriger les permissions

Si le fichier n’a pas le bit exécutable, vous verrez souvent « Permission denied » plutôt que Exec Format Error, mais il est simple à vérifier.

ls -l my_executable
chmod +x my_executable
./my_executable

Fix 4 — Shebang et scripts texte

Un script sans shebang ou avec CRLF peut être mal interprété.

• Vérifiez le début du fichier : head -n 1 script.sh
• Shebang attendu : #!/bin/bash ou #!/usr/bin/env python3
• Convertissez les retours chariot si besoin : dos2unix script.sh

Fix 5 — Format exécutable incompatible (PE, Mach-O, etc.)

Si file indique un format non-ELF (ex. PE pour Windows), vous ne pouvez pas l’exécuter nativement sur Linux sans couche de compatibilité.

Options :

• Pour un exécutable Windows, utilisez Wine (s’il s’agit d’une application Windows utilisateur) : apt install wine
• Pour un binaire macOS (Mach-O), il n’existe pas de portage simple ; recompilez pour Linux ou utilisez une VM macOS si légalement autorisé.

Fix 6 — Exécuter des binaires 32-bit sur 64-bit (Debian/Ubuntu)

Installer la prise en charge i386 (exemple Debian/Ubuntu) :

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

Pour d’autres distributions, installez les paquets de compatibilité correspondants (ia32-libs obsolète, maintenant replaced par multiarch packages).

Fix 7 — Exécuter un binaire ARM sur x86 via qemu-user

Pour tests rapides, qemu-user se révèle précieux : il émule l’ABI au niveau utilisateur.

Sur Debian/Ubuntu :

sudo apt install qemu-user qemu-user-static
# Pour exécuter un binaire ARM :
qemu-arm -L /usr/arm-linux-gnueabihf ./arm_binary

Dans un conteneur Docker multi-arch, on peut utiliser binfmt-support + qemu pour exécuter images ARM sur hôtes x86.

Matrice de compatibilité rapide

Notes :

• « Peut fonctionner (compat) » signifie qu’une couche de compatibilité existe (p.ex. mode i386 sur x86_64).
• Pour ARM→x86, il faut qemu-user ou chroot sur hôte ARM virtuel.

Flux de décision (Mermaid)

flowchart TD
  A[Démarrage : ./mon_binaire] --> B{Erreur ?}
  B -- Non --> C[Succès]
  B -- Oui --> D[Exécuter file]
  D --> E{Format ELF ?}
  E -- Non --> F[Est-ce PE/Mach-O ?]
  F -- Oui --> G[Utiliser Wine/VM ou recompiler]
  F -- Non --> H[Fichier corrompu ?]
  H -- Oui --> I[Retélécharger et vérifier checksum]
  H -- Non --> J{Architecture compatible ?}
  J -- Oui --> K[Vérifier permissions et shebang]
  J -- Non --> L[Installer compatibilité 'multiarch, qemu' ou recompiler]
  K --> M[Appliquer chmod +x ou dos2unix]
  L --> N[Test en container ou qemu]

Checklist par rôle

Devops / Administrateur système

• Vérifier uname -m et file
• Installer paquets multiarch ou qemu si requis
• Fournir packages dans les dépôts internes
• Mettre en place CI qui build pour plusieurs arches

Développeur / Packager

• Cross-compiler pour les architectures cibles
• Fournir checksums et signatures
• Documenter dépendances et shebangs
• Inclure tests d’exécution automatisés dans CI

Utilisateur final

• Vérifier que vous avez la bonne version pour votre machine
• Ne pas exécuter des binaires non signés
• Vérifier les permissions et utiliser dos2unix pour scripts

Plan d’intervention (Playbook rapide)

1. Rassembler : nom du fichier, sortie file, uname -a, logs d’erreur.
2. Isoler : copier le binaire dans un dossier test et refuser l’accès réseau.
3. Vérifier architecture et permissions.
4. Valider checksum et retélécharger si nécessaire.
5. Tester dans un container de la même archétecture.
6. Appliquer solution permanente : déployer binaire rebuildé ou ajouter compatibilité.
7. Documenter la résolution et créer ticket post-mortem si production.

Scénarios particuliers et contre-exemples

• Tentative d’exécuter un binaire Windows (.exe) sur Linux sans Wine → Exec Format Error ou erreur différente ; la solution est Wine ou VM.
• Exécuter avec sh un binaire ELF → affiche des caractères illisibles mais peut aussi renvoyer Exec Format Error selon la commande.
• Un script Python sans shebang lancé directement → « bad interpreter » ; solution : ajouter shebang ou exécuter python script.py.

Tests d’acceptation (critères pour considérer le problème résolu)

• Le binaire s’exécute sans afficher « Cannot Execute Binary File ».
• Pour les binaires dynamiques, ldd n’affiche pas d’erreur « not a dynamic executable » et toutes les bibliothèques requises sont résolues.
• Les logs d’application montrent le comportement attendu (pas de segfault lié au format).
• Documentation mise à jour et checksums fournis.

Plan de rollback (si vous expérimentez des modifications système)

• Conservez un snapshot VM ou sauvegarde du système avant d’installer paquets multiarch/qemu.
• Si la compatibilité créée provoque des régressions, restaurez snapshot et ouvrez un ticket pour analyse approfondie.
• Ne modifiez pas /lib ou /usr/lib manuellement sans sauvegarde.

Conseils de sécurité

• N’exécutez jamais un binaire obtenu de source inconnue sans analyse préalable.
• Validez signatures GPG lorsque disponibles.
• Pour tests d’exécution, utilisez un environnement isolé (container, VM) pour limiter les risques.

FAQ courte

Q : Puis-je exécuter un binaire macOS sur Linux ? R : Non, pas sans une VM macOS ou recompilation pour Linux.

Q : Que faire si file indique ELF mais architecture différente ? R : Installez la couche de compatibilité (multiarch/qemu) ou obtenez une build pour votre architecture.

Q : Pourquoi « bad interpreter: No such file or directory » s’affiche après Exec Format ? R : Cela indique généralement un shebang pointant vers une interpréteur absent, ou un fichier avec CRLF.

Exemples pratiques (scripts et snippets)

Vérification complète automatisée (exemple Shell) :

#!/bin/bash
FILE=$1
if [ -z "$FILE" ]; then
  echo "Usage: $0 "
  exit 2
fi
file_out=$(file "$FILE")
arch=$(uname -m)
echo "file: $file_out"
echo "host arch: $arch"
if echo "$file_out" | grep -q "ELF"; then
  echo "ELF detected"
else
  echo "Non-ELF : vérifier le format (PE/Mach-O) ou le fichier corrompu"
fi
ls -l "$FILE"

Localisation et bonnes pratiques pour la France / Europe

• Privilégiez les dépôts officiels et signatures GPG pour la conformité.
• Documentez clairement les architectures supportées et les dépendances système dans la langue locale.
• Fournissez checksums SHA256 et instructions apt/yum/dnf adaptées aux distributions les plus courantes en Europe.

Résumé et recommandations finales

• Commencez par file et uname -m pour diagnostiquer l’incompatibilité d’architecture.
• Vérifiez l’intégrité du fichier et les permissions.
• Utilisez multiarch, qemu ou conteneurs pour les scénarios cross-architecture.
• Documentez et automatisez la génération de binaires pour les architectures cibles dans votre pipeline CI.

Remarque : si vous êtes bloqué après ces étapes, collectez les sorties de file, uname -a, readelf -h et ldd, puis partagez-les dans un ticket ou forum technique pour un diagnostic approfondi.

Questions, retours ou cas particuliers ? Laissez un commentaire avec les sorties de commandes et l’environnement (distribution, version, architecture) afin d’obtenir une aide ciblée.

Sources et lectures complémentaires

• Guide pratique multiarch et qemu-user pour Debian/Ubuntu

• Documentation officielle des distributions pour la prise en charge i386/aarch64

• Hannah Montana Linux: What is It? Better than other Distro? par J. Shanmugam

• How to List Groups in Linux? par K. Masoun

• How to Install and Use iTunes on Ubuntu? par Shruti Gupta