[assembly] Dimensione istruzioni

[Teo@Unix]

Ciao.
Sapete indicarmi un metodo per risalire alla dimensione in byte di una certa istruzione assembly.

Ad esempio, quanti byte necessitano le istruzioni:

movl $0x0, 0xc(%esi)  // 7 bytes?

che dovrebbero essere diverse da: ( la prima è più dispendiosa )

movl $0x0, %eax // 5 bytes ?

Mi risulta che la dimensione cambi secondo l'OS e CPU. è corretto? Potete indicarmi come fare?
Oppure lo si può fare solo post compilazione con un debugger?

Il punto è che ho inserito dentro un programma C del codice asm con istruzioni tipo jmp indirizzo relativo .... e mi dà l'errore:
"Error: too many memory references for `jmp'", mi spiego? Credo di aver sbagliato a dargli l'indirizzo relativo.
Grazie.

[cdimauro]

Originariamente inviato da Teo@Unix

Ciao.
Sapete indicarmi un metodo per risalire alla dimensione in byte di una certa istruzione assembly. [/code]
La tabella degli opcode dell'ISA x86.
[code]Ad esempio, quanti byte necessitano le istruzioni:

movl $0x0, 0xc(%esi)  // 7 bytes?

che dovrebbero essere diverse da: ( la prima è più dispendiosa )

movl $0x0, %eax // 5 bytes ?

A naso direi che le dimensioni sono corrette.

Mi risulta che la dimensione cambi secondo l'OS e CPU. è corretto?

No, sono sempre le stesse per la stessa ISA.

Potete indicarmi come fare?
Oppure lo si può fare solo post compilazione con un debugger?

Puoi farlo a manina, ma è un casino da consultare l'opcode table.

Meglio utilizzare un assemblatore (che può generare un listato del sorgente originale a cui ha aggiunto i byte delle istruzioni) o un debugger.

Il punto è che ho inserito dentro un programma C del codice asm con istruzioni tipo jmp indirizzo relativo .... e mi dà l'errore:
"Error: too many memory references for `jmp'", mi spiego? Credo di aver sbagliato a dargli l'indirizzo relativo.
Grazie.

Questo è molto strano, perché lo "sbrogliamento" degli offset è a carico dell'assemblatore.

Poi quel messaggio d'errore è la prima volta che lo leggo.

[Teo@Unix]

grazie per la risp.

No, sono sempre le stesse per la stessa ISA.

ok. Quindi i computer moderni sono tutti uguali tra loro.

Meglio utilizzare un assemblatore (che può generare un listato del sorgente originale a cui ha aggiunto i byte delle istruzioni) o un debugger.

Io sono su Linux, quindi già qui mi viene indicata la dimensione giusto? (<main+29> sarà quindi 4 bytes? giusto? Non mi ricordavo più che bastava guardare qui ...)

0x08048269 <main+25>:	mov    0x18(%esp),%eax
0x0804826d <main+29>:	movl   $0x0,0x8(%esp)

Se vuoi dare un'occhiata a gli errori per intero sono questi:

shellcodeasm.c: Assembler messages:
shellcodeasm.c:43: Error: junk `popl %esimovl %esi' after expression
shellcodeasm.c:43: Error: junk `(%esi)movb $0x0' after expression
shellcodeasm.c:43: Error: too many memory references for `jmp'

la riga 43 incriminata è questa:

42  void main() {
43  __asm__(
44  	  "jmp  0x2a"
45  	  "popl %esi"
	  ......

[gugoXX]

Originariamente inviato da Teo@Unix

Il punto è che ho inserito dentro un programma C del codice asm con istruzioni tipo jmp indirizzo relativo .... e mi dà l'errore:
"Error: too many memory references for `jmp'", mi spiego? Credo di aver sbagliato a dargli l'indirizzo relativo.
Grazie.

Mi sa che devi istruire il compilatore ad usare la sintassi Intel e non quella AT&T.

[rеpne scasb]

■

[Teo@Unix]

Puoi fare un semplice software per verificare la dimensione di un'istruzione assembly (x86-32bit):

Codice:
DB 0E8h,0h,0h,0h,0h

; Istruzione di cui si vuole calcolare la lunghezza

DB 0E8h,0h,0h,0h,0h
pop eax
pop ebx
neg ebx
lea eax,[eax+ebx-5h]

; In EAX trovi la dimensione dell'istruzione

buono.
però più che altro mi interessa capire perchè ho dei problemi con la compilazione... per la dimensione me la cavo comunque con gdb.

Mi sa che devi istruire il compilatore ad usare la sintassi Intel e non quella AT&T.

ma come? non posso usare AT&T? In molti manuali vedo AT&T per le inline.

[gugoXX]

Si' che puoi, ma quella sintassi e' la Intel.
Edit: No. Avevo letto male. Prova a mettere le istruzioni Intel e compilare, magari e' proprio il contrario.

[rеpne scasb]

■

[Teo@Unix]

Originariamente inviato da rеpne scasb

E' raro che un compilatore di alto livello ti ritorni correttamente la dimensione di un'istruzione assembly

alla fine se scrivo con sintassi Intel e poi uso objdump per vedere la dimensione dovrei star più tranquillo? ok?

[cdimauro]

Originariamente inviato da Teo@Unix

grazie per la risp.

ok. Quindi i computer moderni sono tutti uguali tra loro.

No. Se montano CPU con ISA diversa, cambia tutto il discorso.

Ma anche se prendi x86 come architettura, x86-64 (l'evoluzione a 64 bit) presenta già delle (succose) modifiche.

Io sono su Linux, quindi già qui mi viene indicata la dimensione giusto? (<main+29> sarà quindi 4 bytes? giusto? Non mi ricordavo più che bastava guardare qui ...)

0x08048269 <main+25>:	mov    0x18(%esp),%eax
0x0804826d <main+29>:	movl   $0x0,0x8(%esp)

Sembra di sì. Gli offset esadecimali corrispondono.

Se vuoi dare un'occhiata a gli errori per intero sono questi:

shellcodeasm.c: Assembler messages:
shellcodeasm.c:43: Error: junk `popl %esimovl %esi' after expression
shellcodeasm.c:43: Error: junk `(%esi)movb $0x0' after expression
shellcodeasm.c:43: Error: too many memory references for `jmp'

la riga 43 incriminata è questa:

42  void main() {
43  __asm__(
44  	  "jmp  0x2a"
45  	  "popl %esi"
	  ......

Non ho mai usato la sintassi AT&T, ma mi sembra che ci siano problemi a fargliela digerire.

In ogni caso non penso che dovresti occuparti tu del calcolo della dimensione delle istruzioni e degli offset per i salti. Dovresti poter dichiarare delle etichette per i salti, e lasciare all'assemblatore il compito di generare le istruzioni di salto in maniera opportuna.

Altrimenti finisce come quando si lavorava in linguaggio macchina, e nel 2010 mi sembra un tantino esagerato.

[Teo@Unix]

Originariamente inviato da cdimauro

No. Se montano CPU con ISA diversa, cambia tutto il discorso.

Capito.

In ogni caso non penso che dovresti occuparti tu del calcolo della dimensione delle istruzioni e degli offset per i salti. Dovresti poter dichiarare delle etichette per i salti, e lasciare all'assemblatore il compito di generare le istruzioni di salto in maniera opportuna.

Altrimenti finisce come quando si lavorava in linguaggio macchina, e nel 2010 mi sembra un tantino esagerato.

Eh eh ... Sono d'accordissimo.
Tutto questo era per capire bene come funziona tutta la faccenda a livello piu basso possibile, vedo che si possono fare cose particolari quando si vanno a ritoccare le istruzioni. Cose che, naturalmente, a livello piu alto non ci si immagina di poter fare.

Per quanto riguarda il problema non ho ancora capito, per ora ho scritto tutto con sintassi intel, che è sicuramente piu pulita. Ed è ok.

[Teo@Unix]

tanto per farvi partecipe, guardate alla fine come doveva essere la inline con AT&T:

void main()
{
	__asm__ (
	"jmp 0x2a\n\t"
	"popl %esi\n\t"
	"movb $0x0, 0x7(%esi)\n\t"
        [....]

        );
}

...

[cdimauro]

E immagino che fosse tutto ben documentato.