Exécution d'un fichier binaire plat sous Linux

Question

Est-il possible d'exécuter une image binaire plat sous Linux, en utilisant une syntaxe quelque chose comme:

nasm -f bin -o foo.bin foo.asm 
runbinary foo.bin 

Answer 1

Y at-il une raison quelconque vous ne voulez pas utiliser « -f elf "au lieu de" -f bin "?

Je pense que Linux n'exécutera pas un binaire qui n'est pas au format ELF. Je ne peux pas trouver un outil qui convertit les fichiers binaires plats à ELF, mais vous pouvez tricher en mettant les informations ELF dans foo.asm, selon la technique décrite here:

Nous pouvons regarder la spécification ELF , et /usr/include/linux/elf.h, et les exécutables créés par les outils standard , pour savoir à quoi devrait ressembler notre exécutable vide ELF. Mais, si vous êtes le genre impatient, vous pouvez simplement utiliser celui que j'ai fourni ici:

BITS 32 

       org  0x08048000 

ehdr:             ; Elf32_Ehdr 
       db  0x7F, "ELF", 1, 1, 1, 0   ; e_ident 
     times 8 db  0 
       dw  2        ; e_type 
       dw  3        ; e_machine 
       dd  1        ; e_version 
       dd  _start       ; e_entry 
       dd  phdr - $$      ; e_phoff 
       dd  0        ; e_shoff 
       dd  0        ; e_flags 
       dw  ehdrsize      ; e_ehsize 
       dw  phdrsize      ; e_phentsize 
       dw  1        ; e_phnum 
       dw  0        ; e_shentsize 
       dw  0        ; e_shnum 
       dw  0        ; e_shstrndx 

ehdrsize  equ  $ - ehdr 

phdr:             ; Elf32_Phdr 
       dd  1        ; p_type 
       dd  0        ; p_offset 
       dd  $$        ; p_vaddr 
       dd  $$        ; p_paddr 
       dd  filesize      ; p_filesz 
       dd  filesize      ; p_memsz 
       dd  5        ; p_flags 
       dd  0x1000       ; p_align 

phdrsize  equ  $ - phdr 

_start: 

; your program here 

    filesize  equ  $ - $$ 

Cette image contient l'en-tête ELF, identifiant le fichier comme un fichier exécutable Intel 386 , avec aucun en-tête de section et une table d'en-tête de programme contenant une entrée. Ladite entrée charge le chargeur de programme pour charger le fichier en mémoire (il est un comportement normal pour un programme de inclure son en-tête ELF et de la table d'en-tête programme dans son image mémoire) à partir de l'adresse mémoire 0x08048000 (qui est le adresse par défaut pour exécutables à charger), et pour commencer l'exécution du code à _start, qui apparaît immédiatement après le programme table d'en-tête. Pas de segment .data, pas segment .bss, pas de commentaire - rien mais le strict nécessaire.

Donc, nous allons ajouter dans notre petit programme:

; tiny.asm 
       org  0x08048000 

; 
; (as above) 
; 

_start: mov bl, 42 xor eax, eax inc eax int 0x80 filesize equ $ - $$ 

et essayer:

$ nasm -f bin -o a.out tiny.asm 
$ chmod +x a.out 
$ ./a.out ; echo $? 
42 

Answer 2

Le noyau Linux peut charger plusieurs formats binaires différents - ELF est juste le plus commun , bien que le format a.out soit également assez connu.

Les formats binaires pris en charge sont contrôlés par les modules binfmt qui sont chargés ou compilés dans le noyau (ils se trouvent sous la section Filesystem de la configuration du noyau). Il y a un binfmt_flat pour les binaires à format plat uClinux BFLT qui sont assez minimes - ils peuvent même être compressés en zlib ce qui vous permettra de réduire encore plus votre binaire, donc cela pourrait être un bon choix.

Il ne semble pas que nasm supporte nativement ce format, mais il est assez facile d'ajouter l'en-tête nécessaire manuellement comme Jim Lewis le décrit pour ELF. Il y a une description du format here.