Scrittura di un eseguibile ELF - status di un i386 dopo la sua esecuzione
Pubblicato da Ritz il 20/05/2000
Livello base

Introduzione

Programmi usati

• nasm: compilatore (assembly sintassi intel)
• ld: linker

Iniziamo

E finalmente ecco che si inizia a programmare... ma prima degli appunti da tenere in considerazione.
Linux, come Win32, gira sui proc Intel x86 in modalità protetta (ring rulezz), e utilizza il modello di memoria flat, quindi abbiamo 4Gb di memoria allocabili come preferiamo (beh vabbè sono meno di 4 Gb., tra SO ecc viene mangiato molto spazio). Per ora non serve saper altro sulla gestione della memoria.

Una nota particolare meritano invece le convenzioni di chiamata: infatti in Linux i parametri di una call non devono essere pushati nello stack come d'altronde accade per gli stessi FreeBSD e BeOS, bensì devono essere messi sequenzialmente nei registri ebx, ecx, edx, esi ed edi, eax contiene il valore di ritorno, lo stack non è nemmeo sfiorato.
Le chiamate al kernel avvengono semplicemente tramite un int 0x80, il numero della chiamata va messo in eax.

La struttura specifica di un file elf potete trovarla nella sezione risorse, cmq anch'essi sono formati da varie sezioni, la .text deve essere sempre presente e rappresenta quella eseguibile, la .data contiene i dati, .bss per i dati non inizializzati.
Detto questo, ecco un sorgente Linux per NASM (sintassi Intel):

section .text ;tipo sezione
global _start ;questo serve per il linker
msg db 'Salve mondo',0xA ;messaggio + carattere invio
len equ $ - msg ;lunghezza messaggio
_start: ;entrypoint
mov edx,len ;edx = lunghezza
mov ecx,msg ;ecx = offset mex
mov ebx,1 ;standard output
mov eax,4 ;numero chiamata (sys_write)
int 0x80 ;chiamata al kernel
mov eax,1 ;numero chiamata
int 0x80 ;chiamata al kernel (sys_exit)

Per quanto riguarda FreeBSD, le regole sono un po' diverse da Linux; ecco lo stesso prg:

section .text
global _start
msg db "Hello, world!",0xa
len equ $ - msg
_syscall:
int 0x80 ;la nostra chiamata al kernel
ret
_start:
push dword len
push dword msg
push dword 1 ;convenzione della chiamata
mov eax,0x4
call _syscall
;si sarebbe potuto chiamare il kernel anche con
;push eax
;call 7:0
add esp,12 ;stack pulito
push dword 0
mov eax,0x1
call _syscall

Per quanto riguarda BeOS, le chiamate sono *identiche* a FreeBSD (lo stesso sorgente non cambia), a parte il fatto che l'int chiamato è 0x25 e i system call number (quelli da mettere in eax) sono diversi (il sys_write è 3 e sys_exit è 3F). Piccola nota: da BeOS i src devono essere compilati col NASM inserendo la riga #include "nasm.h" in float.h e #include <stdio.h> in nasm.h.
Per ulteriori info sul BeOS, consultare il file os_beos.inc delle asmutils.
Per tutti e 3 i sistemi, compilate con $ nasm -f elf ciao.asm, che produrrà l'obj file, e quindi linkate con $ ld -s -o ciao ciao.asm per creare l'eseguibile.
Lanciate dopo aver dato i giusti permessi eventualmente.
E adesso ecco un piccolo approfondimento su cosa accade a grandi linee in un sistema i386 che usi eseguibili ELF (Linux, FreeBSD, BeOS, ecc.) quando un prg viene lanciato (tali cose possono essre facilmente scoperte osservando i file binfmt_rlf.c e sched.h).
Una volta che dalla shell si preme Invio dopo aver scritto il nome di un prg, viene eseguita la call sys_execve(). Ogni prg in memoria ciuccia minimo 2 pagine: una per la sezione .data e una per lo stack, argomenti ed esecuzione. Ecco un classico layout del segmento creato.

Conclusioni

Spero di esservi stato utile, per dubbi chiarimenti proposte ecc. scrivetemi pure a [email protected].
Ciauz a tutti, Ritz.